AgentHub

Agents and sub-agents

An agent is the assistant's complete configuration: tone, AI model, allowed integrations, and sub-agents it can delegate to. The philosophy is to have simple, specialized agents instead of one giant agent that has to know everything.

• Configurable prompt: identity, rules, tone. Editable from the UI.
• Per-agent model: simple agents on cheap models, complex ones on powerful models.
• Sub-agents: invoked as synthetic tools, each with a clear focus.
• Versioned per conversation: changing the prompt doesn't affect conversations in progress.

Integrations OpenAPI

AgentHub talks to your systems through integrations that group tools (specific actions). Integrations are created by uploading the API's OpenAPI spec — the system reads the document, lists the available operations, and generates the tools automatically. No additional development required.

• Automatic import from OpenAPI (URL or file).
• Three authentication modes: no auth, customer token (OIDC), service key (encrypted).
• Incremental re-import: when the API changes, the spec is uploaded again and the tools are updated in place (preserving admin configuration).
• Built-in system tools: product cards, buttons, lists, audio, knowledge-base lookups.

MCP tools Model Context Protocol

AgentHub speaks MCP natively: in addition to your internal APIs via OpenAPI, agents can mount any MCP server from the ecosystem and use it as another tool. This unlocks the entire catalog of standard connectors (filesystem, web search, GitHub, Notion, Jira, databases, observability, etc.) without writing per-project adapters.

• Ready-to-use connectors: registering an MCP server is as simple as adding a URL and, optionally, a credential. AgentHub discovers the exposed tools and makes them available to the agent.
• OpenAPI + MCP coexist: an agent can mix its own OpenAPI tools with MCP tools from the community or internal teams.
• Identical auditing: every MCP call is logged in history with its request, response, and latency, just like OpenAPI calls.
• Your own MCP servers: if your team exposes functionality as an MCP server (in any language), AgentHub consumes it without friction.

Knowledge base

Documents the agent consults to answer with verified information instead of making things up. PDFs, Word, HTML, or plain text — AgentHub extracts the content and makes it available for the agent to use.

• Tool mode: the agent decides when to consult each document. Good when there are many.
• Always-present mode: the document is part of the agent's context all the time. Good for non-negotiable rules.
• Configurable storage: MinIO, S3, or local — binaries live wherever your organization wants them.

Channels multi-channel

AgentHub doesn't force your customers into a single channel — it serves them where they already are, with the same identity and the same conversation continuing across channels:

The customer's identity is stable across channels: if they first write on WhatsApp and later log into the site, AgentHub recognizes them (via OIDC + memory) and continues the same conversation. There's also an internal simulator for testing agents before exposing them, rendering exactly what the end customer would see on each channel.

Customer identity OIDC

Each customer is identified by a stable identifier provided by your identity provider (OIDC). They change phone, email, or device — AgentHub recognizes them and ties all their conversations under the same profile.

If a downstream API rejects the token (expired session), the agent detects the failure, automatically sends the customer a re-login link, and continues the conversation on the next turn.

Customer semantic memory

AgentHub processes each conversation in the background and extracts relevant data worth remembering: brand preferences, products consulted, price sensitivity, purchase frequency. That data is associated with the customer and used as context in future conversations — so the customer never has to repeat themselves.

The same memory is direct input for CRM, segmentation, and marketing, feeding the organization's data exploitation.

LLM history compaction cost control

Every chat turn sends the LLM the full conversation history. In long conversations that means paying for the same content N times and eventually hitting the model's max context window. AgentHub automatically compacts the history the LLM sees: when a conversation crosses a threshold, the oldest turns are replaced by a synthetic summary and the agent keeps full context loaded but stops carrying raw text on every call.

Important note: compaction operates on the LLM history (what is sent to OpenAI) — not on the customer transcript. The WhatsApp / embedded-web record the customer sees stays complete and intact. Compaction is invisible to the customer and reversible for the operator.

• On/off toggle from the UI — no code change, no redeploy.
• Configurable trigger threshold: how many history turns to accumulate before starting to compact.
• Configurable rolling window: how many recent turns to preserve verbatim (new ones always go to the LLM in full).
• Configurable summary model: the summary uses a cheap model by default, independent of the agent's model. Switchable from the UI.
• Editable summary prompt: like the memory-extraction prompt, the operator defines what to preserve (entities, commitments, pending items) and what to ignore (greetings, "ok"/"thanks").
• Coordinates with memory: only compacts turns that mem0 has already processed — never loses a customer fact that was queued for memory extraction.
• Non-destructive: compacted turns remain auditable in the admin history, marked with a "compacted" pill — one click reveals the summary that replaced them. Only the LLM sees the short version.
• Typical savings: in 200+ turn conversations, ~85% fewer input tokens vs. sending the full history on every call.

Observability and auditing

Every conversation is logged with its full transcript, the tools the agent used, calls to your APIs (URL, body, response), latencies, and tokens consumed. Complaints like "the bot told me something weird" are resolved by finding the conversation and reviewing exactly what happened.

• Per-conversation history with every turn (user, agent, tool).
• Detailed API calls: method, URL, status, request body, response.
• Nested sub-agents: when an agent delegates, the detail view shows the flow.
• Aggregated dashboard: costs, top customers, daily conversations, most-failing tools.

Cost control

The AI bill doesn't scale with the number of messages. You set daily and monthly caps in dollars, percentage alerts (50%, 80%, 100%), and individual overrides for premium customers.

When the system crosses a threshold, the agent pauses automatically and notifies the admin. Zero end-of-month surprises.