ARCHITECTURE
What's actually running when your agent runs.
Five layers. Each one engineered for a different job, built to swap independently, and designed to run cloud, hybrid, or fully on-prem. The architecture you'd build for yourself - if you had two years and a platform team.
● Model-agnostic
·
Cloud or on-prem
·
MCP standard
·
OTel-compatible
🧠 Agent Layer
THE BRAIN
Custom AI Agents · Multi-agent Orchestration · Chat-to-build
📚 Knowledge Layer
RAG · CONTEXT · MEMORY
RAG KB · Knowledge Graphs · Document Intelligence · High-fidelity PDF parsing
⚙️ Execution Layer
ACTION · TOOLS · WORKFLOW
Tools + MCP · Workflows · Scheduler · API
🚀 Deployment Layer
INTERFACES
Slack · WhatsApp · Teams · Web · Email · Voice · API
🛡 Enterprise Layer
SECURITY · GOVERNANCE · QA
RBAC · Permissions · Workspace Management · Evaluation
Architecture facts, not architecture claims.
5
SWAPPABLE LAYERS
30+
LLMS
SUPPORTED
< 2s
AVG AGENT RESPONSE
OTel
OBSERVABILITY STANDARD
PRINCIPLES
Four choices we made on purpose.
Most agent platforms inherit their architecture from whatever framework they started with. AgentX is opinionated about a few things - because the alternatives create problems we'd rather not ship to customers.
Model-agnostic at every layer
Orchestrator, sub-agents, evaluation, and embeddings can each use different models. Switch providers without rewriting workflows. Hedge against vendor lock-in by design.
Multi-agent over single-agent
Production work is process work. One agent answers questions. A team of agents runs a process. The platform assumes orchestrator + sub-agents from day one - not as an extension.
Stateless agent execution
Agents are stateless functions. State lives in workspace, memory, knowledge, and audit layers. Stateless execution = horizontal scale + observability + rollback without surprises.
Security at the architecture layer, not at the policy layer
RBAC, isolation, audit, and credential vaulting are part of the runtime, not bolted on. The free tier and the enterprise tier run on the same architecture - they differ in scale and SLA, not in security model.
LAYER 1 — THE BRAIN
Where the agent's reasoning happens.
The Agent Layer is where LLMs are configured, sub-agent teams are coordinated, and reasoning trajectories are produced. It's stateless. It's model-agnostic. And it's the layer that defines what an "agent" actually is on AgentX.
CAPABILITIES
Custom AI agents - per-agent LLM selection (Claude, GPT, Gemini, Llama, Mistral, DeepSeek, custom endpoints)
Multi-agent orchestration - orchestrator + N sub-agents, each with own role, tools, knowledge, permissions
Stateless execution - agent invocations are pure functions; state lives outside the agent
Chat-to-build - agents (and agent teams) creatable via natural language interface
Sub-agent isolation - sub-agents can't be invoked or reverse-engineered through orchestrator prompt injection
Goal-driven loops - multi-round reasoning with explicit termination conditions; not a linear chain
Skills system - pre-built behaviors composable per agent (lead capture, document analysis, structured output)
AGENT EXECUTION FLOW
[ User input or trigger ]
↓
🤖 Orchestrator Agent
Claude 4.6 Sonnet
↓ routes / delegates / escalates
Sub-1
GPT-5
Sub-2
Claude
Sub-3
Llama
↓
[ Synthesized response ]
LAYER 2 — RAG, CONTEXT, MEMORY
Where your agent learns what it doesn't already know.
Three subsystems work together. RAG retrieves relevant context from your private knowledge base. Document intelligence parses complex documents at high fidelity. Memory persists across conversations. All three are accessible per-agent, scoped per-permission, and isolated per-workspace.
RAG KNOWLEDGE BASE
Hybrid search - vector + keyword + reranking
Text-to-SQL for structured data sources
Per-agent access control - agent can read KB α and β but not γ
Citation back to source on every retrieval - auditable
Embeddings model-agnostic - bring your own embeddings provider
DOCUMENT INTELLIGENCE
High-fidelity PDF parsing preserves tables, hierarchy, layout
Large spreadsheet support - Excel with formulas, references, multiple sheets
Image and chart understanding - extracted as structured data, not OCR
Optional human review for low-confidence extractions
No black-box parsing - every extraction logged with confidence score
MEMORY
Per-conversation memory - short-term context within a session
Persistent memory - facts the agent remembers across sessions
Workspace memory - shared facts across agents in the same workspace
Configurable scope - per-sub-agent rules in a team
LAYER 3 — ACTION, TOOLS, WORKFLOW
Where agents actually do things.
Reasoning without action is a chatbot. The Execution Layer is where agents call tools, run workflows, hit external systems, and produce side effects in the real world - with auth, rate limiting, and observability built in.
CAPABILITIES
Tools + MCP - 200+ built-in tools, 1,000+ MCP servers, custom Python tools
Workflow engine - deterministic flows with branching, conditions, loops
Scheduler - cron, webhook, event-triggered, on-demand
Human-in-the-loop - pause workflow at any node for approval
API surface - programmatic agent invocation, streaming responses, batch
Tool call observability - every call logged with parameters, response, latency, cost
Rate limit handling - automatic backoff and queue management per tool
LAYER 4 — INTERFACES
Where agents meet your users.
The Deployment Layer is the abstraction between "agent logic" and "where the conversation happens." Same agent, every channel. Same observability, same eval, same permission model - across API, Slack, Teams, WhatsApp, web, email, voice.
CAPABILITIES
Channel adapters - Slack, Teams, WhatsApp Business, Web Widget, Email, Voice, API, MCP server export
Stateless gateway - channel adapters are thin; agent logic lives in Agent Layer
Versioned development - every channel deployment tagged with agent version
Rollback in seconds - instant version swap without redeploy pipeline
Per channel configuration - same agent can have different greetings, permissions, rate limits per channel
Streaming support - token-level streaming on API and WebSocket interfaces
LAYER 5 — SECURITY, GOVERNANCE, QA
Where the rules get enforced.
The Enterprise Layer cuts through the other four. It's not stacked on top - it's woven through everything. RBAC, audit logging, credential vaulting, evaluation, and workspace isolation operate at every other layer simultaneously.
COMPARED TO
The choices that put us in a different category.
The architecture above isn't the only way to build an agent platform. Here's where AgentX diverges from the three closest alternatives - explicitly, with names.
vs. Workflow Automation
n8n, Zapier
They orchestrate steps. We orchestrate autonomous agents within a role framework. Agents act like employees, not scripts. The difference: who takes responsibility when a step breaks. In step-based orchestration, the system stops. In agent orchestration, the agent reasons about the failure and decides what to do next.
vs. Legacy RPA
UIPath, Automation Anywhere
We don't map screen clicks. We work on language, documents, and unstructured workflows - the territory where modern operations actually live. Screen-recording bots break when UI changes. Agents adapt because they reason about intent, not pixels.
vs. Vendor-Locked Agent Tooling
Agentforce, OpenAI Assistants, Anthropic Agent SDK
We're model-agnostic, with a complete evaluation and governance layer. Sub-agents resistant to reverse engineering. Manager-layer guardrails. On-prem capable. The difference: an agent built on AgentX outlives the model it was built with.
DEPLOYMENT TARGETS
Same architecture. Different places it runs.
The five-layer architecture is the same whether you're running on AgentX Cloud, in your own VPC, or in an air-gapped data center. Same UI, same APIs, same workflows. Only the deployment target changes.
AgentX Cloud
Managed infrastructure
EU data residency available
SOC 2 controls in place
Default for builders, startups, most teams
Start free, scale on demand
Hybrid (Customer VPC)
AgentX runtime in your AWS / Azure / GCP VPC
Data plane on-prem; control plane managed
Compatible with your VPN, peering, private link
Available on Enterprise tier
Fully On-prem
AgentX runtime inside your perimeter
Compatible with self-hosted LLMs (Llama, Mistral, custom)
Air-gapped deployment supported
AgentX provides install, upgrade, support
Scoped per deployment on Enterprise tier
OBSERVABILITY
Built on the observability primitives your team already runs.
AgentX emits traces, metrics, and logs through OpenTelemetry. Export to your existing observability stack - no separate dashboards, no separate alerting. Treat agents like any other service in your infrastructure.
CAPABILITIES
OTel-native - distributed traces, structured logs, metrics - all OpenTelemetry standard
Export targets - Datadog, New Relic, Honeycomb, Grafana, Splunk, any OTel-compatible backend
Built-in dashboards - for teams that don't have an observability stack yet
Alerting hooks - Slack, email, webhook, PagerDuty
Trace retention - 90 days standard, configurable on Enterprise
Compliance log export - separate audit log stream for SIEM ingestion
AgentX
→
OTel Collector
→
Datadog
New Relic
Honeycomb
Splunk
Your backend
Now you know what's running. Here's what you can do with it.
Architecture is the foundation. Build, Evaluate, Deploy, and Integrations are how you actually use it.
Build Agents →
Visual builder, multi-agent orchestration. The Agent Layer in practice.
See builder →
Evaluate Agents →
Pre-deploy testing, eval gates. The Enterprise Layer in practice.
See evaluation →
Deploy Agents →
Channels, versioning, rollback. The Deployment Layer in practice.
See deployment →
Integrations →
Built-in tools, MCP catalog, custom tools. The Execution Layer in practice.
See integrations →
GET STARTED
The stack is open. Build on it.
Free tier runs on the same architecture as the enterprise tier. Different scale, same engineering. Start here, grow without re-platforming.
