Run, orchestrate, and deploy production AI agents at scale — across frameworks and clouds — without lock-in, rewrites, or fragile glue code.

📖 Docs • 🚀 Quick Start • ✨ Features • ☁️ Deploy • 💬 Discord • 🛠 Developer Guide

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.

⭐ If Agent Kernel is solving real problems for you, please star the repo — it's the single best way to help us grow.

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

OpenAI Agents SDK  •  LangGraph  •  CrewAI  •  Google ADK  •  Smol Agents (soon)  •  LiveKit (soon)

No rewrites. No re-learning. Bring your agents — Agent Kernel handles the platform layer.

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) per agent through Module.run_options, 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, and Pydantic Logfire tracing with a single config line.
• Data Residency — Pick your cloud, your region, your storage backend. Your data stays where you need it.

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

Learn more →

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.

Learn more →

Slack • WhatsApp • Microsoft Teams • Telegram • Gmail • Messenger • Instagram

Build once. Ship to every channel your users live on. No bespoke bot code.

• MCP (Model Context Protocol) — Connect agents to external tools, data sources, and services. Optionally expose your agents as MCP tools.
• A2A (Agent-to-Agent) — Native message passing, handoffs, and coordination between agents in a shared ecosystem.
• AG-UI — Stream any agent's run (text, tool calls, reasoning, shared state) to a compliant AG-UI frontend, e.g. CopilotKit.

• Synchronous — Classic request/response.
• WebSocket / Async — Streaming, long-running, real-time agent interactions.
• Stateless MCP — Lightweight agent-as-tool deployments.

Same agent code. Pick your runtime. Full Terraform modules and a Helm chart included.

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):

helm pull oci://ghcr.io/yaalalabs/charts/agent-kernel --version 0.9.3 --untar   # unpacks the flavor values files
helm install ak oci://ghcr.io/yaalalabs/charts/agent-kernel --version 0.9.3 \
  -f agent-kernel/values-dev.yaml \
  --set ioHandler.image.repository=<io image> \
  --set agentRunner.image.repository=<runner image> --set image.tag=<tag>

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.

Install Agent Kernel skills and Claude, Copilot, Cursor, or Windsurf become experts at building production agents — no hallucinated APIs.

ak skill install

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.

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.

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

Agent Kernel is proud to be:

• A member of the Linux Foundation
• A member of the Agentic AI Foundation

• 📖 Documentation: kernel.yaala.ai/docs
• 💬 Discord: Join the community
• 🐛 Issues: GitHub Issues
• 📦 PyPI: pip install agentkernel
• ☁️ Terraform Registry: Official modules
• 🛠 Developer Guide: DEVELOPER_GUIDE.md
• 🤖 Contributing with AI agents: AGENTS.md

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

http://www.apache.org/licenses/LICENSE-2.0

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.

SPDX-License-Identifier: Apache-2.0