Why Agent Kernel?
Built for developers who need flexibility without sacrificing power
Framework Agnostic
Build agents using any AI agentic framework and migrate them to Agent Kernel to benefit from its execution framework capabilities. No vendor lock-in - seamlessly migrate between LangGraph, OpenAI Agents SDK, Google ADK, CrewAI, and custom frameworks without rewriting your agent logic.
Production Ready
Enterprise-grade features including built-in session management, conversational state tracking, pluggable memory backends, comprehensive traceability with LangFuse and OpenLLMetry, and multi-agent collaboration support. Deploy with confidence from day one.
Deploy Anywhere
From CLI testing for local development to REST API servers, AWS serverless, containerized environments, or on-premise deployments. One codebase, multiple deployment options. Switch deployment modes without changing your agent code.
Versatile Integrations
Built-in integrations for popular messaging platforms including Slack, WhatsApp, Messenger, Instagram, Telegram, and Gmail. Support for MCP Server and A2A Server protocols. Easy-to-build custom integrations with pluggable architecture.
Core Features
Everything you need to build sophisticated AI agents
Agent Design & Definition
Define agents with clear roles, capabilities, and behaviors using intuitive Python APIs. All framework adapters expose the same core abstractions: Agent, Runner, Session, Module, and Runtime.
- Python-first SDK
- Unified API across frameworks
- Role-based design
- Flexible configuration
Tool Integration
Bind custom tools, APIs, and functionalities to your agents for enhanced capabilities. Publish tools via MCP Server for Model Context Protocol integration.
- Custom tool support
- API integrations
- MCP tool publishing
- Pluggable architecture
Hierarchies & Collaboration
Create agent teams with complex topologies, hierarchies, and collaborative workflows.
- Multi-agent systems
- Agent hierarchies
- Collaborative patterns
Context & Memory
Smart memory management with volatile (request-scoped) and non-volatile (session-persistent) caching. Supports multiple backends: in-memory, Redis, and DynamoDB.
- Volatile cache for RAG context
- Non-volatile cache for user preferences
- Multiple backend support
- Clean prompts, lower costs
Execution Hooks
Powerful pre and post-execution hooks for surgical control over agent behavior. Implement guard rails, RAG context injection, response moderation, and custom logic.
- Pre-hooks: guard rails, RAG, auth
- Post-hooks: disclaimers, moderation
- Hook chaining & composition
- Framework-agnostic
Fault Tolerance
Production-grade resilience with multi-AZ deployments, automatic failure recovery, and health monitoring for high availability.
- Multi-AZ deployment
- Auto-recovery
- Health monitoring
- Zero downtime
Traceability & Observability
Comprehensive tracking of agent actions, LLM calls, and collaborative operations.
- LangFuse integration
- OpenLLMetry support
- Multi-level verbosity
MCP & A2A Support
Built-in Multi-Context Processing and Agent-to-Agent communication capabilities.
- MCP integration
- A2A messaging
- Cross-agent coordination
Content Safety & Guardrails
Built-in guardrails for content safety and compliance with support for OpenAI and AWS Bedrock guardrail providers.
- Input/output validation
- PII detection & redaction
- Content moderation
- Jailbreak protection
Framework Support
Work with your favorite agentic frameworks
OpenAI Agents SDK
Full support for OpenAI's agentic framework with seamless integration.
Learn more →LangGraph
Build stateful, multi-actor applications with LangChain's graph framework.
Learn more →Google ADK
Leverage Google's Agent Development Kit for advanced agent capabilities.
Learn more →CrewAI
Orchestrate role-playing autonomous AI agents for complex tasks.
Learn more →Smart Memory Management
Two types of intelligent caching with identical APIs but different lifecycles. Volatile cache for request-scoped data, non-volatile for session persistence. Multiple backends (in-memory, Redis, DynamoDB) swap with just environment variables.
Volatile Cache
Request-scoped temporary storage that auto-clears after execution. Perfect for RAG context, file content, and intermediate data without cluttering prompts.
- RAG search results
- Document content from uploads
- Temporary calculations
- Request-scoped feature flags
Non-Volatile Cache
Session-persistent storage that survives across multiple requests. Ideal for user preferences, metadata, and configurations.
- User preferences
- Session metadata
- Extracted information
- Persistent configurations
Redis Backend
High-performance distributed memory backend for production workloads with persistent state across instances.
- Production deployments
- Multi-process apps
- Distributed systems
- Session persistence
DynamoDB Backend
Serverless, auto-scaling NoSQL backend for AWS deployments with configurable TTL and pay-per-use pricing.
- AWS Lambda deployments
- Auto-scaling apps
- Serverless architectures
- AWS-native infrastructure
Testing & Development
Comprehensive testing framework with CLI and automated testing, multiple comparison modes, and seamless pytest integration. Test your agents thoroughly before deployment.
CLI-Based Testing
Interactive command-line interface for real-time agent testing and debugging. Test your agents in a controlled environment with the Test class for programmatic interaction.
- Interactive chat sessions
- Real-time feedback
- Persistent CLI sessions
- Multi-agent support
- ANSI escape sequence cleanup
Automated Test Framework
Build comprehensive test suites with pytest integration. Execute predefined scenarios to validate agent behavior consistently across deployments.
- pytest integration
- Session-scoped fixtures
- Ordered test execution
- CI/CD ready
- Container testing support
Three Powerful Comparison Modes
Choose the right validation strategy for your use case. All modes support multiple expected answers and configurable thresholds.
Fuzzy Mode
Fast string matching with configurable thresholds using RapidFuzz
- Configurable threshold (0-100)
- Multiple expected answers support
- Deterministic results
- Ideal for exact outputs
Judge Mode
LLM-based semantic evaluation using Ragas for AI-generated content
- Answer similarity metric
- Answer relevancy check
- Handles paraphrasing
- Best for AI responses
Fallback Mode
Tries fuzzy first, then falls back to judge evaluation (default)
- Best of both worlds
- Automatic fallback
- Robust validation
- Production-ready
Configurable Modes
Set default mode via config.yaml or environment variables
Multi-Agent Support
Test different agents within the same CLI application
API Testing
Test REST API endpoints alongside CLI agents
Container Testing
Validate containerized deployments before production
Deployment Options
Ready-to-use execution capabilities for every environment. Deploy anywhere, from local development to global scale production, without changing your agent code.
Local Development
Test and develop agents locally with the built-in Agent Tester utility.
- CLI-based interaction
- Automated test scenarios
- Rapid iteration
- No cloud dependencies
AWS Serverless
Scale dynamically with serverless architecture for variable workloads.
- Lambda-based execution
- Auto-scaling
- Pay-per-use pricing
- Zero infrastructure management
AWS Containerized
Consistent performance with container-based deployment on AWS.
- ECS/EKS support
- Lower latency
- Predictable performance
- Resource optimization
On-Premise / Docker
Deploy in your own infrastructure with REST API and Docker support.
- Full control
- Docker containerization
- REST API included
- Custom infrastructure
Infrastructure as Code
Deploy with confidence using our official Terraform modules. One-command deployment to AWS with best practices baked in.
View Terraform ModulesObservability & Traceability
Complete visibility into agent operations
Multi-Level Traceability
Track every action, decision, and LLM call with configurable verbosity levels.
- Agent action tracking
- LLM call monitoring
- Collaborative operation logs
- Performance metrics
Integrated Observability Tools
LangFuse
Comprehensive LLM observability and analytics platform
TraceLoop OpenLLMetry
OpenTelemetry-based observability for LLM applications
Content Safety & Compliance
Protect users and ensure compliance with built-in guardrails
Multi-Layer Protection
Validate content before and after agent processing to ensure safety and compliance.
- Input validation before agent processing
- Output validation before user delivery
- PII detection and redaction
- Content moderation and filtering
- Jailbreak and prompt attack detection
- Topic and keyword-based blocking
Supported Guardrail Providers
OpenAI Guardrails
Flexible LLM-based content validation with custom rules and policies
AWS Bedrock Guardrails
Enterprise-grade content filtering with 30+ PII types and contextual grounding
Ready to Build Your AI Agents?
Agent Kernel is ideal for AI engineers who want framework flexibility, teams building production AI agent systems, developers migrating between frameworks, organizations requiring enterprise-grade deployment, and researchers exploring different agent frameworks.
Get started with Agent Kernel today and bring your agentic applications to production.