Skip to content

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.

Start freeRead the technical docs
  • Model-agnostic
  • Cloud or on-prem
  • MCP standard
  • OTel-compatible

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.

  1. 01

    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.

  2. 02

    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.

  3. 03

    Stateless agent execution

    Agents are stateless functions. State lives in workspace, memory, knowledge, and audit layers. Stateless execution = horizontal scale + observability + rollback without surprises.

  4. 04

    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)

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.

See the full integrations catalog

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

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 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.

See all deployment channels

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.

Security primitives

  • RBAC - admin, editor, viewer roles per workspace; granular permissions per agent
  • SSO - SAML 2.0, OIDC; Azure AD, Okta, Google Workspace
  • Workspace isolation - data, agents, knowledge, audit logs scoped per workspace
  • Credential vault - OAuth tokens and API keys encrypted at rest, never exposed to agent context
  • Audit logging - every agent action, tool call, knowledge retrieval, human override logged
  • PII handling - configurable redaction rules per workspace, applied before LLM calls

Governance + QA primitives

  • Evaluation pipeline - built-in LLM-as-judge, custom rubrics, versioned eval runs
  • Deploy gate - promotion criteria block deploy until eval passes
  • Production monitoring - score drift detection, anomaly alerts
  • Override logging - every manual override logged with name, reason, timestamp
  • Data residency - EU residency on cloud; on-prem for full control
  • SOC 2 control - controls in place; certification in progress
Enterprise featuresSecurity details

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

In practice

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.

01

Build Agents

Visual builder, multi-agent orchestration. The Agent Layer in practice.

See builder02

Evaluate Agents

Pre-deploy testing, eval gates. The Enterprise Layer in practice.

See evaluation03

Deploy Agents

Channels, versioning, rollback. The Deployment Layer in practice.

See deployment04

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.

Free

$0

/ forever

Build and test your first agent.

Try it
Solo Builder

$49

/ month

Solo builders shipping production agents.

Get started
Professional/Business

$199 - $299

/ month

Agencies and service teams with white-label deployment.

See plans
Enterprise

Custom

scoped per process

On-prem, SSO, dedicated infrastructure.

Talk to us

Start Your AI Automation Journey Today

Sign up for AgentX and let AI handle your routine tasks - no credit card needed.

Get Started - FreeView Pricing