Install the full suite
pip install "mcpaisuite-kernelmcp[all]"The complete AI agent operating system.
The agent stack where memory, RAG, sandbox, scheduler, web search, and planning are all native — not plugins you wire and maintain.
10 independent libraries, plus runtime access to any MCP server or LangChain tool (2000+ and 500+ reachable in their ecosystems). pip install just what you need.
Lean Task Protocol compiles your goal into a deterministic plan in 1 LLM call, then executes it in Python. Same input → same output — and far fewer tokens than multi-turn ReAct for deterministic tasks.
5 stores: HotCache (LRU) → Working (TTL) → Episodic (sessions) → Semantic (vector) → FactGraph (relations). Temporal versioning, decay scoring, contradiction detection, GDPR forget.
Memory + RAG + Sandbox + Scheduler + Web Search + Files + Plans — all native, tested together, one audit trail, one config. No glue code, no adapter hell.
120+ native tools + any of the 2000+ community MCP servers (Notion, GitHub, Slack, Postgres…) + 500+ LangChain tools. Connect at runtime, no wrapper code needed.
Agent: autonomous ReAct+LTP execution. Router: client drives tools directly, zero double API calls. Sampling: uses the client’s LLM — zero API keys, zero cost.
MetaAgent analyzes past runs, identifies failures and bottlenecks, and auto-tunes the constitution and LTP templates. Your agents get better over time.
Embed kernelmcp in your own apps and point them at a Hub you host. connect_hub() reports every kernel’s traces to one place over an outbound-only connection — and you can opt into remote control (config, cancel, run). Not a telemetry collector you ship data to: a control plane your own kernels connect to. Your runtime, your data.
Rules live at the execution layer — not in a system prompt the model can ignore. A DLP secret guard redacts AWS keys, tokens and private keys before they reach the model and blocks secret-carrying outbound calls; budget caps, loop detection and approval gates stop runaway or destructive agents. Compiled LTP plans can even be statically verified against a policy before a single step runs. Every block carries a reason and is replayable.
Each server is a standalone MCP package — plus a full-stack demo app. Install one, or install them all.
ReAct + LTP hybrid engine, constitution, auto-healing, budget enforcement.
Learn more →Facts, episodes, and semantic search that survive across sessions.
Learn more →Turns complex goals into executable task trees with LTP protocol.
Learn more →Docker sandbox with network deny-all, resource limits, auto-cleanup.
Learn more →Read, edit, multi-edit, apply patches, search (ripgrep), and organize files within sandboxed workspaces.
Learn more →Cron jobs, delayed tasks, recurring workflows, and time-based triggers.
Learn more →Ingest documents, chunk, embed, and search with semantic similarity.
Learn more →SearXNG, DuckDuckGo, Playwright browser fetch, clean markdown extraction.
Learn more →Judge strategies, golden datasets, and benchmark suites for MCP agents. Python library, CLI, and MCP server.
Learn more →Deterministic plan execution with explicit data flow and conditional logic.
Learn more →Production-ready orchestration dashboard. Chat, agents, knowledge graphs, workspace, scheduler, observability — all in one.
Learn more →kernelmcp orchestrates everything. Each library exposes MCP tools that the ReAct engine calls as needed.
Budget enforcement, circuit breaking, auto-healing, and audit logging active at every layer
Each capability below is its own tested library — usable on its own, or wired together by the kernel. Most agent frameworks give you the reasoning loop and leave memory, retrieval, sandboxing, search and scheduling to third-party plugins you integrate and maintain yourself. Here they’re one stack, one audit trail, one pip install.
| Capability | Native library | What you get |
|---|---|---|
| Persistent memory | memorymcp | 5 stores (HotCache → Working → Episodic → Semantic → FactGraph), decay scoring, GDPR forget |
| Retrieval (RAG) | ragmcp | Self-RAG + ReAct-RAG, hybrid / SPLADE / ColPali retrieval, native eval metrics |
| Deterministic execution | ltpmcp | LTP compiles the plan in one LLM call, runs it in pure Python — same input → same output, statically verifiable |
| Code sandbox | sandboxmcp | Docker + process backends, network deny-all by default, opt-in Landlock hardening |
| Task scheduling | schedulermcp | cron · interval · once · watch, with retry backoff and a dead-letter queue |
| Web search | websearchmcp | 4 engines + Playwright browser fetch + cross-encoder rerank — $0, no API key |
| Planning | planningmcp | Goal decomposition into task trees, 8 built-in templates, cost estimation |
| File management | workspacemcp | Sandboxed edits + apply_patch, auto-checkpoints, DLP redaction, approval gates |
| Orchestration & governance | kernelmcp | ReAct + LTP engine, constitution, DLP secret guard, budget + loop caps — enforced at the execution layer |
Every row is a standalone package on PyPI — pip install one, or kernelmcp[all] for the whole stack. All MCP-native.
No single piece is a knockout of its best-in-class incumbent — most are “parity + a specific edge.” What you won’t find bundled elsewhere is the whole governed stack, at near-zero marginal cost. Every figure below reproduces from a script with raw JSON in its repo; losses are shown as plainly as wins.
All four frameworks hit 100% — reliability is a tie. kernelmcp Hybrid is the cheapest 100%-reliable system: 2.6× / 3.1× under LangGraph / CrewAI on Sonnet (compile-once + caching).
Recall close and split (recall@1 0.775 vs 0.500, Mem0 wins recall@5). The clear win is cost: deterministic extraction is $0 vs $0.071/8 facts.
We lose the raw index (authority@3 3/10 vs 6/10) — but match the cited answer (5/6 tie) at $0 / no key. The price of no index is latency.
Zero-dependency process backend contains 3/5 host-impact escapes; the Docker backend 5/5, verified on the host filesystem. Real defense-in-depth, honestly bounded.
Install the orchestrator. Start the agent. Everything else is auto-discovered via MCP.
pip install "mcpaisuite-kernelmcp[all]"from kernelmcp import KernelFactory
kernel = KernelFactory.full_suite(
llm_model="claude-sonnet-4-6",
api_key="sk-...",
)
result = await kernel.run("Search for Python MCP libraries and write a comparison report")
print(result.summary){
"mcpServers": {
"kernel": {
"command": "kernelmcp",
"args": ["start"]
}
}
}# Each library works standalone (installs as mcpaisuite-*, imports as the short name)
pip install mcpaisuite-memorymcp # then: import memorymcp
pip install mcpaisuite-ragmcp # then: import ragmcp
pip install mcpaisuite-sandboxmcp # then: import sandboxmcpKernelFactory wires all servers and establishes MCP connections.
LTP compiles a deterministic plan, or ReAct reasons step-by-step.
Tools are called across all servers to fulfill each sub-task.
Auto-retry, fallback strategies, and re-planning on failure.
Structured result with execution traces and cost breakdown.