Agent Kernel is the open-source operating system for scalable, compliant enterprise AI agents. Build, test, and deploy with OpenAI, LangGraph, CrewAI, Google ADK, Smolagents, Pydantic AI, Microsoft Ag
EvoX Genesis turns a high-level software objective into a persistent recursive software world: finite-lived agents recursively develop software, while only accepted consequences persist across develop
Native Shell: AI-generated UI, native in your app, on every platform. Apps on iOS, Android, macOS, Windows and Linux, GPUI apps and web pages load signed, sandboxed TSX modules at run time and draw th
A free, open source personal AI agent that is always on, proactive and sessionless. Self-host your open source alternative to Muse, Dots, Instinct and Town.
The Operating System for Scalable Enterprise AI Agents - Run, orchestrate, and deploy Compliant Enterprise AI Agents at scale across frameworks, without lock-in, rewrites or fragile glue code. Native support for MCP, A2A. Interface with all mainstream communication channels seamlessly out of the box, production ready from day one.
Most agent frameworks help you build a prototype. Agent Kernel is the platform layer that gets you to production — with the governance, portability, and operational maturity that enterprises actually require.
Agent Kernel
🔌 Framework-Agnostic
Run OpenAI Agents SDK, LangGraph, CrewAI, Google ADK, Smolagents, Pydantic AI, and Microsoft Agent Framework side by side. Swap with 2 import lines.
☁️ Cloud-Agnostic
The same agent code ships to AWS Lambda/ECS, Azure Functions/Container Apps, GCP Cloud Run, or on-prem.
🔁 Queue-Pipeline Execution
Every chat request runs through a queued pipeline: in-process by default (zero services, full retry/FIFO/dedup semantics locally), SQS, Kafka, and NATS JetStream transports for distributed deployments; a Helm chart ships the topology to any Kubernetes cluster.
Pluggable session stores (Redis, Valkey, DynamoDB, Cosmos DB) + knowledge bases (ChromaDB, Neo4j, Starburst, Open Knowledge Format bundles).
💬 Channels Built-In
Slack, WhatsApp, Teams, Telegram, Gmail, Messenger, Instagram, and LiveKit — out of the box.
🔍 Production Observability
LangFuse, OpenLLMetry, Pydantic Logfire, and AWS CloudWatch tracing wired in. Every agent run — visible, with LLM and tool calls where the framework supports it.
🤝
Open Standards
Native MCP (Model Context Protocol), A2A (Agent-to-Agent), AG-UI (streamed event protocol for agent-facing frontends), and A2UI (generative UI documents, labelled from config) support.
🆓 Apache 2.0
No licensing fees. No vendor lock-in. Production-ready open source.
⭐ If Agent Kernel is solving real problems for you, please star the repo — it's the single best way to help us grow.
🚀 Quick Start
Requirements: Python 3.12 – 3.13.x
pip install agentkernel
Build a multi-agent system that runs on OpenAI Agents SDK today and LangGraph tomorrow — same code:
from agentkernel.cli import CLI
from agentkernel.openai import OpenAIModule
from agents import Agent
math_agent = Agent(
name="math",
handoff_description="Specialist agent for math questions",
instructions="You provide help with math problems.",
)
general_agent = Agent(
name="general",
handoff_description="Agent for general questions",
instructions="You provide assistance with general queries.",
)
triage_agent = Agent(
name="triage",
instructions="You determine which agent to use based on the user's question.",
handoffs=[general_agent, math_agent],
)
module = OpenAIModule([triage_agent, math_agent, general_agent])
if __name__ == "__main__":
CLI.main()
That's it. Same code deploys to AWS Lambda, ECS, Azure Functions, or Container Apps with a single Terraform module, or to any Kubernetes cluster with the Helm chart. 👉 Get Started
✨ Features
🧩 Works with the Frameworks You Already Use
No rewrites. No re-learning. Bring your agents — Agent Kernel handles the platform layer.
🛡️ Compliance & Governance — First-Class, Not an Afterthought
Enterprises can't ship agents they can't audit. Agent Kernel makes compliance the default:
Guardrails — OpenAI and AWS Bedrock guardrails for PII detection, jailbreak prevention, content moderation.
Pre/Post Execution Hooks — Inject policy checks, RAG context, redaction, or moderation around every agent call.
Framework-Native Run Options: Pass each framework's own run arguments and lifecycle hooks (OpenAI RunHooks and RunConfig, LangGraph callbacks, ADK plugins, Pydantic AI usage limits, Microsoft Agent Framework options) per agent through Module.run_options, statically or computed per run by a factory, with the keys Agent Kernel owns kept safe.
Full Traceability — Every agent action, tool call, and LLM invocation logged with configurable verbosity.
Observability — LangFuse, OpenLLMetry, Pydantic Logfire, and AWS CloudWatch tracing with a single config line.
Secret Resolution — Resolve API keys from the environment locally and from AWS SSM Parameter Store or mounted Kubernetes Secrets in production via SecretManager, with only config.yaml changing.
Data Residency — Pick your cloud, your region, your storage backend. Your data stays where you need it.
📦 Sandboxed Code Execution
Let agents run code and shell commands in an isolated, permission-bounded environment — the platform handles it, your agent code stays clean.
Enable it in config — agents automatically gain code/command/file tools and the usage guidance is injected into their prompt.
Pluggable providers — local_subprocess (dev), docker (container-isolated), kubernetes (pod per sandbox, RBAC as the boundary), e2b (managed micro-VMs), daytona (cloud containers), and ec2_ssm (attach to an existing EC2 instance); bring your own via a dotted path.
Workload profiles — per-call, per-session, or shared lifetimes; each with its own permission policy (network egress, filesystem, CPU/memory, timeout, run_code languages, package installs) enforced fail-closed.
Per-user identity — run sandboxed code under the invoking user's identity, not one shared agent identity, via a pluggable principal resolver.
Let a chat run later, or on a schedule — the platform owns the timers, the persistence, and the management API.
Enable it in config — a schedule block turns on deferring and the agent tools with no code change; mount ScheduleRESTRequestHandler when you also want the management routes.
One creation path, three callers — a schedule block on any chat request (acknowledged with HTTP 202), the agent's own create_schedule tool, or a direct ScheduleManager call.
Pluggable timers and stores — local (in-process, for development) or AWS EventBridge Scheduler for production; task records in memory, Redis, Valkey, or DynamoDB.
Managed over REST — list, read, amend, pause and cancel via /api/v1/schedules, scoped to the owning user by a pluggable Authoriser.
Let a run stop to ask a person something — approve this tool, answer this question — and resume from their decision minutes or hours later, on any replica.
Nothing to enable — declare a gated tool or an interrupt the way your framework already does; Agent Kernel returns HTTP 202 with status: "PAUSED" and the pending interruptions.
Answer instead of prompting — send a resume block with approved, denied, or cancelled per interruption, plus the human's own words or a structured value.
Five frameworks pause — OpenAI Agents SDK, LangGraph, Pydantic AI, Google ADK, and Microsoft Agent Framework; the others say they can't rather than pretending.
Every surface — REST, streaming, WebSocket, and AG-UI's interrupt outcome; durable across restarts on any shared session backend.
Helm chart (baremetal + EKS, Kafka/NATS queue mode, KEDA autoscaling)
Kubernetes / On-Prem with Helm
The chart is published as an OCI artifact at
ghcr.io/yaalalabs/charts/agent-kernel.
Install it with Helm (the docker pull command GitHub shows on the package page does not apply to charts):
Flavors are values files over one set of templates: values-dev.yaml for a local cluster, values-baremetal.yaml for self-hosted, values-eks.yaml for AWS EKS. Valkey and NATS ship as bundled dependencies, and every image the chart references is listed in the images.txt attached to each release for air-gapped mirroring. Full guide: On-Prem / Kubernetes Deployment.
🛠 Agent Skills — Supercharge Your Coding Assistant
Install Agent Kernel skills and Claude, Copilot, Cursor, or Windsurf become experts at building production agents — no hallucinated APIs.
ak skill install
Skill
What it does
ak-init
Scaffold a new project — any framework, any deployment mode
ak-build
Add tools, agents, handoffs — context-aware and framework-specific
AWS Lambda, ECS, Azure Functions, Container Apps, GCP Cloud Run with full Terraform
ak-test
Score, llm, and fallback test modes (pluggable evaluators) + a debugging playbook
See the use-cases/ directory for complete end-to-end examples built using these skills — each starting from a SPEC.md and generating a fully deployed agent.
🧪 Testing — pytest-Integrated
pytest tests/
Built-in score, llm, and fallback comparison modes, backed by a pluggable evaluator (DeepEval by default, or bring your own). CI/CD ready. Test agent behavior, not just code.
👥 Who's It For?
AI Startups — Go from prototype to production in days, not quarters.
Software Product Companies — Add intelligent agents to your SaaS without framework lock-in.
Software Services Companies — Ship client agent solutions in weeks, not months.
Domain Experts — Build production AI products without a full platform engineering team.
Regulated Enterprises — Get compliance, traceability, and data residency by default.
Unless otherwise specified, all content — including all source and documentation files in this repository — is:
Copyright (c) 2025-2026 Yaala Labs.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
