The platform every agent we ship runs on
ANT is our own agentic AI platform — the runtime, retrieval, handoff and governance layer underneath every client deployment. We built it so each engagement is configuration rather than construction.
Live
theant.space →What needed solving
The distance between a chatbot that demos well and a system you can put in front of someone else's customers is almost entirely unglamorous work: grounding answers in approved content, handing the conversation to a person when it needs judgment, keeping one client's data away from another's, letting an agent act on business systems without letting it act carelessly, and knowing what any of it costs. That is where pilots die — not at the model.
Rebuilding that layer per engagement is slow, and worse, it is risky in exactly the places you cannot afford a second attempt: tenant isolation, rate limits, credential handling, cost control. So we built it once, as a platform, and treat each client deployment as configuration on top of it.
How we built it
Agents are deterministic graphs, not a prompt in a loop. Each agent type compiles its own LangGraph `StateGraph` over a typed state object, with named nodes for retrieval, generation, tool execution, handoff and error handling. The topology differs by purpose: a support agent classifies intent first and can route straight to a human before it ever generates text, while a lead-generation agent continues past the reply into contact extraction, qualification and capture.
Retrieval is deliberately narrow. Content is embedded into pgvector inside Postgres and queried through a single matching function scoped to one agent, so an agent can only ever retrieve what it was given. Ingestion covers uploaded files, crawled websites, question-and-answer pairs and plain text; the crawler drives a real browser for JavaScript-rendered pages, discovers URLs from sitemaps, and falls back to plain HTTP when the browser path fails. Chunking strategy varies by document type, because a requirements document and a brochure do not split the same way.
We took conversation state into our own tables rather than using the framework's checkpointer. The platform needs to read and act on a live conversation from outside the graph — the handoff inbox, the analytics views, an operator stepping in mid-session — and opaque checkpoint blobs do not support that. Sessions and transcripts are first-class rows we can query.
Handoff is a path through the graph, not an escape hatch bolted on afterwards. It supports live takeover and callback modes, respects per-workspace availability schedules and timezones, and streams to the operator console over server-sent events, backed by a shared pub/sub layer so it still works across multiple API workers.
For acting on the outside world we split brain from hands. ANT decides; a separate sandboxed runtime executes the Python that talks to third-party systems, because retries, timeouts, scheduling and secret storage are problems that layer already solves well. Integrations reach the model as tools generated from database rows, so enabling a capability for an agent is a configuration change rather than a deployment.
Governance is in the foundation rather than added later: workspace-scoped tenancy with row-level security in Postgres, JWT auth for the dashboard and scoped keys for programmatic access, per-agent rate limits, encrypted integration credentials, and credit metering that accounts for tokens per message so cost is attributable per agent.
What it runs on
What shipped
A graph runtime with purpose-built topologies for support, lead generation, billing enquiry, appointment booking and general conversational agents.
Retrieval over four ingestion paths — file upload, website crawl, Q&A pairs and plain text — with chunking tuned per document type.
Human handoff with live and callback modes, availability schedules, and an operator inbox fed over server-sent events.
Tool calling into a maintained library of roughly ninety integration workflows spanning CRM, Salesforce, Shopify, Jira, Google Calendar, email and practice-management systems.
Workspace multi-tenancy enforced with Postgres row-level security, plus scoped API keys for programmatic access.
Per-agent rate limiting, credit metering with token-level accounting, and plan-based model allowlists.
Four LLM providers behind one interface, including encrypted bring-your-own-key credentials per workspace.
Two delivery channels out of the box: an embeddable web widget and WhatsApp via the Business Cloud API.
An internal operations dashboard for monitoring live agents, cost and subscriptions.