# Axiom | Governed Tool Layer for AI Agents & Enterprise MCP Gateway > Axiom is the in-VPC governed tool layer and enterprise Model Context Protocol (MCP) gateway for autonomous AI agents. It intercepts tool calls, enforces deterministic parameter schemas, caps monetary spend rates, and provides human-in-the-loop review before state mutations touch enterprise ERPs, databases, or APIs. Last updated: 26 Oct 2026. Production-ready architecture. ## Primary Documentation & Architecture Specs - [Architecture Overview](https://axiom.neoai.solutions/docs/): Technical specification of the Axiom governed tool layer and 5-stage interception pipeline. Plain-text: https://axiom.neoai.solutions/docs/full.txt - [MCP Enterprise Security](https://axiom.neoai.solutions/docs/mcp-security/): Model Context Protocol security, tool discovery masking, rate limits, and prompt injection defense. Plain-text: https://axiom.neoai.solutions/docs/mcp-security/full.txt - [Agent Verification & Guardrails](https://axiom.neoai.solutions/docs/agent-verification/): Deterministic JSON schema verification, ledger invariants, and continuous staging replay. Plain-text: https://axiom.neoai.solutions/docs/agent-verification/full.txt ## Architectural Comparisons - [Axiom vs Traditional API Gateways](https://axiom.neoai.solutions/vs/api-gateways/): Why Kong, Apigee, and AWS API Gateway fail to protect backends from autonomous agent loops. Plain-text: https://axiom.neoai.solutions/vs/api-gateways/full.txt - [Axiom vs Framework Tools](https://axiom.neoai.solutions/vs/langchain-tools/): Centralized in-VPC gateway governance vs in-process LangChain/LlamaIndex Python tool execution. Plain-text: https://axiom.neoai.solutions/vs/langchain-tools/full.txt ## Engineering Guides - [Back-Office Automation Guide](https://axiom.neoai.solutions/guides/back-office-automation/): How enterprises safely automate legacy back-office handoffs with human-in-the-loop oversight. Plain-text: https://axiom.neoai.solutions/guides/back-office-automation/full.txt ## Contact & Architecture Review - Website: https://axiom.neoai.solutions/ - Contact: founders@axiomlayer.com - Full consolidated reference: https://axiom.neoai.solutions/llms-full.txt ================================================================================ # DOCUMENT: Axiom Documentation | Governed Tool Layer Architecture for AI Agents URL: https://axiom.neoai.solutions/docs/ # The Governed Tool Layer: Technical Architecture for Autonomous AI Agents > The Axiom Governed Tool Layer is an in-VPC reverse proxy and deterministic enforcement engine that sits between autonomous AI agent frameworks and enterprise systems. It validates tool parameters against strict JSON schemas, intercepts out-of-bounds spend or state mutations, and provides auditable human-in-the-loop escalation before state changes touch production ledgers or APIs. ## The Autonomous Tool Problem in Production AI When software engineers transition autonomous AI agents from conversational prototypes to production systems with API write access (e.g. ERP systems, Salesforce, SAP, Stripe, PostgreSQL), probabilistic model behavior introduces systemic risks that traditional HTTP gateways cannot mitigate: - **Hallucinated Parameters & Schema Drift:** LLMs generate syntactically valid JSON containing non-existent parameters, inverted debit/credit flags, or out-of-range numerical values. - **Unbounded State Mutation & Financial Runaway:** A reasoning loop attempting to reconcile a supplier dispute can issue repeated API write calls with unconstrained spend authority (e.g. issuing duplicate $25,000 refund drafts). - **Prompt Injection via Tool Output:** Malicious or malformed data retrieved from a third-party CRM can inject hidden instruction overrides into subsequent agent reasoning steps. - **API Breaking Changes & Silent Drift:** Upstream SaaS updates or deprecated RFC fields cause agent tool executions to fail catastrophically in production without pre-execution validation. ## Axiom Enforcement Pipeline Architecture Axiom operates as a zero-trust intermediary for Model Context Protocol (MCP) servers, REST endpoints, and database connectors. Every agentic tool invocation flows through a deterministic, sub-10ms five-stage pipeline: 1. **Ingestion & Identity Authentication:** Validates Task Token, Agent Identity, and Nonce. 2. **Deterministic Schema Validation:** Strict JSON Schema checking with type coercion blocked. 3. **Policy & Ceiling Arbitration:** Validates spend thresholds, allowed verbs, and rate limits. - If within bounds: proceeds to upstream execution (SAP, Stripe, Postgres) and passes output through Result Sanitization. - If out of bounds: halts execution immediately and raises an asynchronous Human-in-the-Loop approval hold. ## Key Capabilities Matrix | Capability | Traditional API Gateway | Framework Tool Calls | Axiom Governed Layer | |---|---|---|---| | Inspection Level | HTTP Header & Route Token | In-Memory Function Call | Semantic Payload & Context | | Parameter Validation | Loose OpenAPI Spec | Pydantic (Client-only) | Deterministic Strict Bounds | | Financial Ceilings | Rate limits by IP/QPS only | None | Cumulative Task Spend Caps | | Human Approval Gate | Custom webhook required | Custom graph logic | Built-in Async Hold Queue | | Audit Trail | Standard HTTP access logs | Local stdout/traces | Signed State Action Log | ## Architectural Guarantees 1. **In-VPC Isolation:** Deploys as a lightweight container in the customer VPC. Credentials and data never leave customer boundaries. 2. **Sub-10ms Overhead:** Typical policy evaluation latency is 4.2ms to 8.4ms. 3. **Continuous Staging Replay:** Automatically tests historical agent traces against staging when enterprise APIs update. ## Frequently Asked Questions ### What is an AI Agent Tool Layer? An AI Agent Tool Layer is an infrastructure proxy that sits between autonomous LLM agents and enterprise APIs. It enforces deterministic boundaries, parameter schema validation, financial spend caps, and human approval gates on actions initiated by probabilistic AI models. ### How does Axiom differ from Model Context Protocol (MCP)? Axiom is fully compatible with MCP. While MCP standardizes how tools and resources are exposed to AI models, Axiom provides the enterprise governance layer over MCP—enforcing rate limits, spend ceilings, prompt injection sanitization, and audit logging on top of standard MCP servers. ### Where does Axiom deploy? Axiom deploys inside your own VPC or Kubernetes cluster via Docker/Helm. Your API keys, database credentials, and business payloads remain strictly within your security perimeter. ### Does Axiom require rewriting existing agent code? No. Axiom exposes a drop-in OpenAI-compatible tool call endpoint and standard MCP proxy URL. You simply point your agent tool client to the Axiom gateway endpoint. --- Canonical URL: https://axiom.neoai.solutions/docs/ Updated: 2026-10-26 -------------------------------------------------------------------------------- # DOCUMENT: Model Context Protocol (MCP) Enterprise Security & Governance | Axiom URL: https://axiom.neoai.solutions/docs/mcp-security/ # Enterprise Security for Model Context Protocol (MCP): Tool Governance & Isolation > Model Context Protocol (MCP) standardizes how LLM agents discover and invoke external tools, but lacks native enterprise security primitives. Axiom provides the governed enterprise MCP gateway—enforcing zero-trust tool access, parameter-level bounds, spend rate ceilings, and bidirectional prompt injection sanitization on all MCP client-server exchanges. ## The Model Context Protocol (MCP) Security Blind Spot Anthropic's Model Context Protocol (MCP) has rapidly emerged as the open industry standard for connecting LLM applications to external tools, databases, and third-party APIs. However, standard MCP architecture assumes a benign, trusted execution environment. In production enterprise deployments, this assumption breaks down across three vectors: - **Unconstrained Tool Discovery:** Agents automatically discover all exposed MCP tools, allowing a conversational model to call high-risk operational tools without granular role-based authorization. - **Bidirectional Prompt Injection:** Untrusted external data returned by an MCP resource server can contain adversarial prompt injection instructions that hijack subsequent tool calls. - **Unbounded Cost & Transaction Caps:** MCP specifies tool schemas but provides no native mechanisms to enforce cumulative budget caps or transaction limits per agent session. ## Axiom MCP Security Architecture Axiom acts as a transparent, security-enforcing reverse proxy between your MCP client and downstream MCP servers, enforcing: 1. Tool Discovery Masking based on Agent IAM. 2. Strict Schema Invariants with type coercion blocked. 3. Spend & State Ceilings with automated Human-in-the-Loop escalation. 4. Payload Sanitization against indirect prompt injection. 5. Cryptographically signed audit trails for compliance. ## Frequently Asked Questions ### Does Axiom slow down MCP tool execution? No. Axiom is engineered in high-performance Go/Rust. Average latency overhead for full schema verification, ceiling arbitration, and audit logging is between 3.8ms and 7.2ms—well below the 500ms+ network latency of LLM inference. ### Can Axiom prevent indirect prompt injection in MCP tools? Yes. Axiom inspects data returned from downstream MCP servers (e.g. database rows, scraped web pages, support tickets) and sanitizes adversarial prompt injection tags before returning the payload to the LLM agent reasoning loop. ### What happens when an agent exceeds an MCP spend limit? Rather than failing catastrophically and crashing the workflow, Axiom pauses the task and issues an asynchronous Human-in-the-Loop review request via webhook, email, or Slack. Once approved by an authorized manager, execution resumes seamlessly. ### Is Axiom compatible with Claude Desktop and Cursor? Yes. Axiom acts as a standard MCP proxy endpoint. You can configure Claude Desktop or Cursor to point directly to Axiom as an MCP server. --- Canonical URL: https://axiom.neoai.solutions/docs/mcp-security/ Updated: 2026-10-26 -------------------------------------------------------------------------------- # DOCUMENT: Agent Tool Verification & Parameter Guardrails | Axiom URL: https://axiom.neoai.solutions/docs/agent-verification/ # Deterministic Parameter Verification & Guardrails for Autonomous Agents > Axiom Parameter Verification is an in-line validation engine that intercepts agent tool calls before API dispatch. It enforces strict JSON schemas, prevents LLM type coercion bugs, validates domain invariants (such as zero-sum ledger entries), and blocks hallucinated or undeclared arguments from reaching enterprise backends. ## Why Probabilistic LLMs Require Deterministic Verification Modern agent frameworks frequently rely on "LLM-as-a-judge" or self-reflection prompts to evaluate whether a tool call is safe. In production enterprise environments, this probabilistic approach creates critical failure modes: - **Probabilistic Blind Spots:** An LLM evaluating another LLM has the same distribution blind spots, missing errors in 22% to 38% of edge cases. - **Latency Multiplication:** Invoking an LLM judge adds 800ms to 2,500ms of latency per step. - **Silent Type Coercion:** Silent coercion between strings, floats, and integers corrupts precision in accounting and inventory systems. ## Deterministic Invariant Verification Axiom replaces probabilistic checking with compiled, deterministic verification engines that evaluate parameters against hard mathematical and business rules in less than 2 milliseconds. ## Continuous Staging Regression Suite 1. **Trace Capture:** Captures masked production tool payloads and execution graphs. 2. **Sandbox Execution:** Nightly replay against staging instances of ERPs and CRMs. 3. **Automated Patch Scoping:** Generates schema adaptation policies when upstream APIs change. ## Frequently Asked Questions ### How does deterministic verification compare to LLM-as-a-judge? Deterministic verification uses compiled code and strict mathematical rules to guarantee compliance in <2ms with zero false positives. LLM-as-a-judge is slow (1-3s), expensive, and probabilistic, missing edge cases in 22-38% of complex scenarios. ### What happens when an agent tool call violates a business invariant? Axiom blocks the request instantly, preventing any state modification in upstream databases. It returns a structured error to the agent explaining exactly which invariant failed, allowing the agent to self-correct its reasoning. ### Can Axiom validate custom SQL queries from text-to-SQL agents? Yes. Axiom includes an AST-based SQL parser that inspects queries generated by text-to-SQL agents, blocking DROP, DELETE, TRUNCATE, or unconstrained UPDATE statements before execution. --- Canonical URL: https://axiom.neoai.solutions/docs/agent-verification/ Updated: 2026-10-26 -------------------------------------------------------------------------------- # DOCUMENT: Axiom vs Traditional API Gateways (Kong, Apigee, AWS) | Governed Tool Layer URL: https://axiom.neoai.solutions/vs/api-gateways/ # Axiom vs Traditional API Gateways: Why AI Agents Break Standard Edge Proxies > Traditional API gateways (Kong, Apigee, AWS API Gateway) were designed for deterministic microservices and human web traffic, policing IP rate limits, OAuth scopes, and route mapping. In contrast, Axiom is purpose-built for autonomous AI agents—evaluating semantic payload validity, cumulative multi-step spend caps, Model Context Protocol (MCP) tool security, and async human-in-the-loop escalation. ## The Fundamental Architectural Mismatch Enterprise API gateways cannot distinguish between a legitimate human-triggered request and a runaway LLM reasoning loop. They measure requests per second (QPS), not semantic spend or cumulative financial liability. ## Key Differences | Dimension | Traditional API Gateway | Axiom Governed Tool Layer | |---|---|---| | Caller Model | Deterministic microservices | Probabilistic LLM agents | | Rate Limiting Logic | IP / API key QPS | Task-scoped cumulative monetary caps | | Payload Validation | Basic JSON syntax | Semantic business invariants | | Protocol Support | REST, GraphQL, gRPC | MCP, OpenAI Tool Calls, REST, SQL | | Threshold Violation | Immediate 429/403 failure | Async human-in-the-loop hold | | Prompt Injection | None | Sanitizes tool outputs before model context | ## Reference Architecture Axiom deploys directly in front of internal enterprise backends, operating in harmony with your existing edge gateways. ## Frequently Asked Questions ### Does Axiom replace our Kong or Apigee deployment? No. You continue running Kong or Apigee for your edge API routing, mobile apps, and external partner traffic. Axiom sits inside your VPC between your autonomous AI agents and internal APIs to provide agent-specific governance. ### Can we just write custom plugins for Kong to do this? Custom Kong plugins run into severe limitations: Kong is designed for high-throughput packet routing, not stateful task tracking across multi-step agent reasoning sessions, nor does it support MCP protocol decoding or indirect prompt injection sanitization. ### What is the latency impact of adding Axiom behind an API gateway? Axiom adds between 4.2ms and 8.4ms of latency. In an AI agent workflow where LLM inference steps take 800ms to 3,000ms each, Axiom overhead is imperceptible. --- Canonical URL: https://axiom.neoai.solutions/vs/api-gateways/ Updated: 2026-10-26 -------------------------------------------------------------------------------- # DOCUMENT: Axiom vs LangChain & LlamaIndex Tools | Governed Agent Infrastructure URL: https://axiom.neoai.solutions/vs/langchain-tools/ # Axiom vs Framework-Native Tools: Centralized Governance vs In-Process Code > Framework-native tool systems (such as LangChain Tools, LlamaIndex FunctionTools, and CrewAI Tools) run in-process inside your application runtime, scattering API credentials, policy checks, and audit logic across disparate codebases. Axiom provides a centralized, out-of-process in-VPC governance gateway where enterprise security policies, spend limits, and compliance logs are managed independently of agent application code. ## The Problem with In-Process Framework Tools - **Decentralized Credential Sprawl:** High-privilege API tokens scattered across multiple microservices. - **Hardcoded Policy Logic:** Business checks embedded in Python scripts require full redeployments to change. - **Zero Unified Auditability:** Fragmented stdout logs make compliance auditing impossible. - **Process Isolation Failure:** Errors or infinite loops crash core application processes. ## Architecture Comparison | Evaluation Criteria | Framework-Native Tools | Axiom Governed Tool Layer | |---|---|---| | Execution Boundary | In-process (Python/TS runtime) | Out-of-process In-VPC Gateway | | Credential Management | Distributed across app instances | Centralized in Axiom KMS integration | | Policy Management | Hardcoded code logic | Declarative dynamic YAML policies | | Language Neutrality | Framework-dependent | Universal HTTP / MCP interface | | Human-in-the-Loop | Custom checkpoint state machines | Native async escalation queue | | Compliance Audit | Fragmented application logs | Cryptographically signed immutable log | ## Frequently Asked Questions ### Can I use Axiom with LangGraph or CrewAI? Yes. Axiom is completely framework-agnostic. Whether you use LangGraph, AutoGen, CrewAI, or raw OpenAI/Anthropic SDKs, you simply direct tool execution requests to Axiom. ### What happens if an engineer bypasses Axiom and calls the DB directly? In standard zero-trust enterprise network topologies, enterprise production databases and ERP endpoints only accept incoming traffic from the Axiom gateway security group, preventing direct agent bypass. ### How are human approval workflows handled in LangChain? Without Axiom, developers must write complex state checkpointing and interrupt logic into LangGraph. With Axiom, the gateway holds the execution promise asynchronously, triggers the notification, and completes the HTTP response once approved. --- Canonical URL: https://axiom.neoai.solutions/vs/langchain-tools/ Updated: 2026-10-26 -------------------------------------------------------------------------------- # DOCUMENT: Enterprise Back-Office Automation with Human-in-the-Loop | Axiom Guide URL: https://axiom.neoai.solutions/guides/back-office-automation/ # Enterprise Back-Office Automation with Human-in-the-Loop | Axiom Guide > Enterprise back-office automation with AI agents enables organizations running legacy software to eliminate manual copy-and-paste handoffs without hiring engineering armies. By combining autonomous task discovery with deterministic boundaries, organizations execute standard operations automatically while escalating edge cases or high-value transactions to human staff for review. ## The Legacy Software Dilemma Mid-market and enterprise organizations are trapped between $300k+ custom integration projects, fragile RPA screen-scrapers, and risky unconstrained AI agents. ## The Four-Stage Blueprint 1. **Read-Only Workflow Discovery:** Maps how work moves between systems by watching read-only logs. 2. **Deterministic Boundary Definition:** Sets strict monetary caps and invariant business rules. 3. **Zero-Code Tool Mediation:** Generates governed MCP connectors to legacy systems. 4. **Continuous Closed-Loop Audit:** 100% of actions and human approvals captured in an immutable audit ledger. ## Measurable Business Impact - 85% reduction in manual handoffs. - Zero ledger corruption through deterministic parameter validation. - Live in production within a 6-week founding pilot. ## Frequently Asked Questions ### Do we need an internal engineering team to deploy Axiom? No. You describe your operational process in plain English. Axiom discovers the connections, configures the governed connectors, and provides intuitive human approval dashboards for operations teams. ### What happens if our legacy software has no REST API? Axiom interfaces with legacy systems through database connectors (Postgres, Oracle, SQL Server), SFTP batch pipelines, or standardized enterprise MCP proxies. ### Does our financial data leave our corporate network? No. Axiom is designed to deploy within your own cloud account (AWS, GCP, Azure, or on-premise Kubernetes), ensuring all customer data and API credentials stay within your security perimeter. --- Canonical URL: https://axiom.neoai.solutions/guides/back-office-automation/ Updated: 2026-10-26 --------------------------------------------------------------------------------