Why Agent Kernel
Everything You Need to Build, Run and Scale AI Agents
From runtime and memory to guardrails, observability, testing, and multi-cloud deployment.
BRING YOUR FRAMEWORK
- OpenAI
- LangGraph
- CrewAI
- Google ADK
- Smolagents
- Pydantic AI
- LiveKit
Agent Kernel
AK Runtime
Sessions | Hooks | Observability | Sandbox
DEPLOY ANYWHERE
- AWS Lambda / ECS
- Azure Functions / ACA
- GCP Cloud Run
- On-prem / Docker
REACH USERS ON
- Slack · Teams · Gmail
- REST · MCP · A2A
- Telegram · Messenger
- WhatsApp · Instagram
✦Feature Map
Everything Agent Kernel Does
Seven production-ready capabilities. Explore any area below.
01: The Problem
The Problem Agent Kernel Solves
Building production AI agents today involves solving many hard problems that have nothing to do with the actual agent intelligence.
Platform Engineering
Without vs. with Agent Kernel
Without Agent Kernel
What you take on today
Build REST APIs, auth, session management, deployment pipelines from scratch
With Agent Kernel
What the platform covers
All included out of the box
02: Core Capabilities
Core Capabilities
Everything you need to build, run, and scale production AI agents without building platform code.
Six Core Abstractions
Learn MoreAgent, Runner, Session, Module, Runtime, and Tools, a unified API across all frameworks. Build once, run on any supported framework.
- Unified Python API
- Framework adapters for 4 SDKs
- Portable tool functions via ToolBuilder
- Framework-agnostic hooks
Framework-Neutral Runtime
Learn MoreOpenAI Agents, LangGraph, CrewAI, Google ADK, Smolagents, and Pydantic AI, run them all simultaneously in one runtime. Switch frameworks by changing 2 import lines.
- OpenAI Agents SDK
- LangGraph
- CrewAI
- Google ADK
- Smolagents
- Pydantic AI
Execution Hooks
Learn MorePre and post-execution hooks give you surgical control over every agent request, for any framework.
- Pre-hooks: guardrails, RAG, auth, validation
- Post-hooks: moderation, disclaimers, analytics
- Hook chaining and composition
- Early termination with custom responses
Smart Memory Management
Learn MoreVolatile and non-volatile caching with identical APIs but different lifecycles. Swap backends with just environment variables.
- Volatile: request-scoped, auto-clears
- Non-volatile: session-persistent
- Backends: In-memory, Redis, DynamoDB, Cosmos DB
- Clean prompts, reduced token usage
Knowledge Bases
Learn MoreBuilt-in retrieval for curated knowledge sources and storage for agent reinforcement learning. Neo4j, Starburst Galaxy, ChromaDB, and custom SQL data sources.
- ChromaDB — vector/semantic search
- Neo4j — entity and relationship graphs
- Starburst Galaxy — SQL over MongoDB, Sheets, PostgreSQL
- semantic_map keeps agent prompts portable
Sandboxed Code Execution
Learn MoreAgents run code, shell commands, and file operations in isolated sandboxes. The Execution Broker routes every execution to a pluggable, policy-governed provider, in-process or over a queue to a separate worker fleet.
- local_subprocess, docker, kubernetes, e2b, daytona, ec2_ssm
- Queue broker over SQS, Kafka, or NATS for long-running executions
- Session-persistent workspaces
- Fail-closed network, filesystem, CPU, and memory policies
- Agent or end-user identity
Multi-Cloud & On-Prem Deployment
Learn MoreOne agent codebase deploys to AWS, Azure, GCP, or your own Kubernetes cluster: Terraform modules for the clouds, a Helm chart for on-prem. No vendor lock-in, ever.
- AWS Lambda (Serverless)
- AWS ECS/Fargate (Containerized)
- Azure Functions (Serverless)
- Azure Container Apps (Containerized)
- GCP Cloud Run (Serverless)
- GCP Cloud Run (Containerized)
- On-Prem Kubernetes (Helm chart: bare metal, EKS, air-gapped)
- Queue-backed scaling: ingress and agent execution scale independently
Fault Tolerance
Learn MoreProduction-grade resilience with multi-AZ deployments, auto-recovery, health monitoring, and rolling deployments.
- Multi-AZ for high availability
- Automatic failure recovery
- Health monitoring
- Zero-downtime deployments
Observability
Learn MoreFull visibility into agent execution, LLM calls, and tool invocations. One config line to enable.
- Langfuse integration
- OpenLLMetry (OpenTelemetry-based)
- Pydantic Logfire integration
- Multi-level verbosity
- Cost and latency tracking
Content Safety & Guardrails
Learn MoreInput and output guardrails that protect users and ensure compliance. Plugs in via execution hooks.
- PII detection and redaction
- Jailbreak prevention
- Content moderation
- Off-topic filtering
MCP & A2A Protocols
Learn MoreExpose agents as MCP tools or enable agent-to-agent communication via A2A protocol.
- MCP Server mode
- A2A Server mode
- Cross-agent coordination
- Protocol-future-proofed
03: Sandboxed Execution
Sandboxed Code Execution
Agents write code; Agent Kernel gives it a safe place to run. Every execution flows through the Agent Kernel Execution Broker to a pluggable, policy-governed provider: in-process for CLI and REST deployments, or over a queue to a sandbox worker fleet that keeps running after the agent turn ends. All chosen in configuration.
Agent
OpenAI · LangGraph · CrewAI · Google ADK · Smolagents · Pydantic AI
any agentic frameworkSandbox Tools
run_code · run_command · files · sessions
sandbox session
per_session · per_call · per_runtime
Security Policy
network · filesystem · cpu · memory · timeout
Agent Kernel
Execution Broker
thread · embedded · queue flavors
in-process
thread · embedded
runs inside the agent process · CLI and REST
queue-decoupled
Request queueSandbox Worker fleet
Response storeOutput queue
sqs · kafka · nats · in_memory · bounded wait, then check_sandbox_task
Local Subprocess Provider
host process · dev only
Local Sandbox
no isolationDocker Provider
your Docker daemon
Docker Sandbox
containerKubernetes Provider
pod per sandbox · RBAC boundary
Kubernetes Pod
container
E2B Provider
E2B cloud · stateful kernel
E2B Sandbox
micro-VM
Daytona Provider
Daytona cloud · snapshots
Daytona Sandbox
containerEC2 SSM Provider
attached environmentexisting instance via SSM
EC2 Instance
no isolationBring Your Own
any SandboxProvider subclass
Custom Sandbox
declared tier04: Framework Support
One Runtime, Any Framework
Use the best framework for each job, and run them all together in a single deployment.
OpenAI Agents SDK
Official OpenAI agents framework with full support for tools, handoffs, and streaming.
Learn More
LangGraph
Graph-based agent orchestration for complex stateful multi-actor applications.
Learn More
Google ADK
Google's Agent Development Kit for advanced agent capabilities and Gemini integration.
Learn More
CrewAI
Role-based multi-agent framework for orchestrating collaborative AI workflows.
Learn More
Smolagents
Hugging Face's Smolagents with first-class support for writing your own coding agents.
Learn More
Pydantic AI
Pydantic-team framework with native multi-provider models, FallbackModel failover, and typed structured output.
Learn More
LiveKit
LiveKit provides the complete stack for voice-based AI agents.
Learn More
Agent Kernel
Multi-Framework
Run agents from multiple frameworks simultaneously in a single runtime — no glue code required.
05: Testing
Testing & Evaluation
Test your agents like any other code. CLI testing for development, automated suites for CI/CD, three comparison modes, and a pluggable evaluator interface behind all of them.
CLI Testing
Interactive sessions for rapid development iteration and multi-agent testing.
- Interactive chat sessions
- Real-time feedback
- Persistent CLI sessions
- Multi-agent support
Automated Tests
pytest-integrated test suites that run in CI/CD with session-scoped fixtures.
- pytest integration
- Session-scoped fixtures
- Ordered test execution
- CI/CD ready
Pluggable Evaluators
Every comparison runs through an AKEvaluator. DeepEval ships built in; swap in your own backend with one line of test-config.yaml.
- DeepEval built in: quasi-exact match and GEval
- Bring your own AKEvaluator subclass
- Selected by short name or dotted path
- Backend failures raise, never read as a failing agent
Comparison modes
Score Mode
Deterministic, offline scoring with no LLM call. Normalised exact match against any expected answer. Ideal for fixed outputs.
LLM Mode
LLM-as-judge semantic evaluation. Gives credit when a short expected phrase sits inside a longer, correct response.
Fallback Mode
Tries score first, falls back to LLM. The default, and the best of both worlds.
06: Messaging
Messaging Integrations
Your agents meet users on the channels they already use. Every integration routes through the same Agent Kernel runtime. Pick a channel below for setup steps.
07: Protocol
Protocol Support
Standard protocols for tool connectivity and multi-agent coordination. Wired into the runtime.
MCP - Model Context Protocol
Model Context Protocol (MCP) is a standardized interface that lets AI models connect to external tools, data sources, and services in a structured, consistent way. It acts as a bridge between an AI's reasoning and real-world actions, enabling agents to retrieve information and execute tasks reliably. Agent Kernel natively supports running an MCP server, including exposing your agents as MCP tools.
MCP Server DocsA2A - Agent-to-Agent
Agent-to-Agent (A2A) is a communication pattern where multiple AI agents interact directly with each other to share context, delegate tasks, and coordinate decisions. It enables complex workflows by allowing specialized agents to collaborate instead of relying on a single monolithic system. Agent Kernel natively supports exposing any agent over the A2A protocol by switching configuration.
A2A Server Docs
