AI agents fail in predictable ways: they lose state on crash, call tools they shouldn't, skip human approval, run past budget, forget context, or leave no useful audit trail.
JamJet is an open-source runtime that handles those failure modes directly: policy checks, audit trails, human approval, crash recovery, cost limits, durable memory, and MCP/A2A interoperability.
Keep your framework. Add JamJet when an agent needs to be replayable, auditable, and controlled.
89% of enterprise agents never reach production. JamJet exists to fix that. — for developers shipping agents that need to survive crashes, unsafe tool calls, runaway costs, missed approvals, and audit gaps.
| Without JamJet | With JamJet |
|---|---|
| Agent crashes lose progress | Resume from the last checkpoint |
| Tool calls rely on scattered app logic | Runtime policies block unsafe actions |
| Human approval is custom glue code | Approval is a durable workflow step |
| Costs are discovered after the bill | Budgets enforced per agent / per run |
| Audit evidence is stitched from logs | Every run has an execution trail |
| Memory is framework-specific | Engram works via MCP, REST, Python, Java |
| Agent frameworks stay isolated | MCP + A2A connect tools and agents |
pip install jamjetfrom jamjet import task, tool
@tool
async def web_search(query: str) -> str:
return f"Search results for: {query}"
@task(model="claude-haiku-4-5-20251001", tools=[web_search])
async def research(question: str) -> str:
"""You are a research assistant. Search first, then summarize clearly."""
result = await research("What is JamJet?")No server. No config. No YAML. Just pip install and run. → Full quickstart
Add JamJet Cloud's two-line config and the same code gains policy enforcement, cost budgets, human approval, and an audit trail:
import jamjet.cloud as jamjet
from openai import OpenAI
jamjet.configure(api_key="jj_...", project="my-agent")
jamjet.policy("require_approval", "payments.*") # risky tools wait for human OK
jamjet.budget(max_cost_usd=5.00) # cap spend per run
# Every OpenAI / Anthropic call is now traced, policy-checked, and counted toward the budget.
OpenAI().chat.completions.create(
model="gpt-4o-mini",
messages=[{"role": "user", "content": "..."}],
)Every run shows up in app.jamjet.dev/dashboard/traces within ~5 seconds — model, tokens, cost, duration, every tool call. → Cloud Quickstart
| Problem | JamJet's answer |
|---|---|
| Unsafe tool calls slip through | Policy engine — block, allow, or require approval per tool pattern |
| No audit trail of agent decisions | Append-only event log + audit export |
| Agent crashes lose progress | Event-sourced execution with checkpoint resume |
| Human approval is custom glue | First-class pause/resume approval step |
| Costs run away on long agents | Per-run / per-agent budgets with enforcement |
| Memory is framework-specific | Engram memory via MCP, REST, Python, Java |
| Agents stuck in one framework | MCP + A2A client + server interoperability |
| Python orchestration bottlenecks | Rust + Tokio runtime; Python and Java SDKs |
| Need a hosted control plane | JamJet Cloud — drop-in two lines for traces, policy queue, audit retention. See Cloud Quickstart. |
Three levels of abstraction — all compile to the same IR and run on the same engine.
@task — one function, zero boilerplate
@task(model="claude-haiku-4-5-20251001", tools=[web_search])
async def research(question: str) -> str:
"""You are a research assistant."""Agent — explicit configuration
agent = Agent("researcher", model="claude-haiku-4-5-20251001",
tools=[web_search], instructions="Search first, then summarize.")
result = await agent.run("What is JamJet?")Workflow — full graph control
workflow = Workflow("research")
@workflow.step
async def search(state: State) -> State:
result = await web_search(query=state.query)
return state.model_copy(update={"answer": result})YAML — declarative workflows
nodes:
think:
type: model
model: claude-haiku-4-5-20251001
prompt: "Answer clearly: {{ state.query }}"
output_key: answer
next: endCoordinator — dynamic agent routing. Discover agents by skill, score them, route to the best fit at runtime. Structured scoring with optional LLM tiebreaker, full scoring breakdown in event logs. Example →
Agent-as-Tool. Wrap any agent as a callable tool — sync (quick, stateless), streaming (long-running with budget limits), or conversational (multi-turn with turn limits). Example →
MCP — client + server. Connect to external MCP tool servers in workflows, or expose JamJet tools as an MCP server for Claude Desktop, Cursor, and other clients. Example →
A2A protocol — client + server. Delegate tasks to external agents or serve tasks from other frameworks via Agent-to-Agent protocol. Example →
Eval harness. Built-in LLM judge, assertions, cost scoring. Self-improvement loop with on_fail: retry_with_feedback. Example →
Human-in-the-loop. First-class approval primitive — pause execution, collect human input, resume. Example →
Engram is JamJet's durable memory layer — temporal knowledge graph, hybrid retrieval, fact extraction, conflict detection, and consolidation. Backed by SQLite (zero-infra) or PostgreSQL (production). Ships with a built-in message store for conversation history.
Provider-agnostic. One binary speaks to Ollama (local, free), any OpenAI-compatible endpoint (OpenAI, Azure, Groq, Together, DeepSeek, …), Anthropic Claude, Google Gemini, or a shell-out command — set ENGRAM_LLM_PROVIDER=… and go.
| Package | Install from | Use case |
|---|---|---|
jamjet-engram |
crates.io | Embed in Rust apps |
jamjet-engram-server |
crates.io · Docker · MCP Registry | MCP + REST server |
jamjet |
PyPI | Python client |
dev.jamjet:jamjet-sdk |
Maven Central | Java client |
dev.jamjet:engram-spring-boot-starter |
Maven Central | Spring AI ChatMemoryRepository |
# Try with Claude Desktop — uses local Ollama by default
docker run --rm -i -v engram-data:/data ghcr.io/jamjet-labs/engram-server:0.5.011 MCP tools: memory_add, memory_recall, memory_context, memory_search, memory_forget, memory_stats, memory_consolidate, messages_save, messages_get, messages_list, messages_delete.
Full docs → runtime/engram-server/README.md · Comparison with Mem0, Zep, and others → java-ai-memory.dev
Spring AI? LangChain4j? Plain Java? The JamJet Java Runtime embeds durable execution directly in your JVM. No Docker, no sidecar, no REST overhead — and 8.9× faster than calling out to one.
@DurableAgent
@Service
public class MyAgent {
@Checkpoint("search")
public String search(String topic) {
return chatClient.prompt("Research: " + topic).call().content();
}
}
// Kill the process. Restart. It resumes from the last checkpoint.<dependency>
<groupId>dev.jamjet</groupId>
<artifactId>jamjet-runtime-spring-boot-starter</artifactId>
<version>0.1.1</version>
</dependency>Virtual threads, MCP native, plugin hot-reload. Works with Spring AI, LangChain4j, Google ADK. Read the launch post.
Free OSS forever. This runtime, Engram local, both SDKs, and the Java runtime are Apache-2.0 — no usage limits, no telemetry.
JamJet Cloud is the optional hosted layer for teams that need shared visibility:
- Traces — every run with model, tokens, cost, duration, every tool call
- Policy violations + approval queue — human OKs in one place
- Budgets + cost attribution — per agent, per project, per environment
- Hosted Engram memory — multi-tenant, no infrastructure
- Audit retention + export — evidence-grade logs for compliance
- Team projects + environments — dev / staging / prod isolation
Two lines to wire it in:
import jamjet.cloud as jamjet
jamjet.configure(api_key="jj_...", project="my-agent")Multi-agent network graph + Java cloud SDK ship Q3 2026. → Cloud Quickstart · Sign up
The strategy is simple: keep your framework, add JamJet for runtime safety.
| Tool category | Use it for | JamJet adds |
|---|---|---|
| LangChain · LangGraph · CrewAI · Google ADK | Authoring agent behavior | Runtime safety: policy, audit, replay, approvals |
| LangSmith · Arize · Weights & Biases | Observability and evaluation | Active enforcement (block at runtime) + durable recovery |
| Temporal · Orkes · DBOS | General durable workflows | Agent-native primitives: policy on tool calls, MCP/A2A, memory |
| Google · AWS · Azure agent platforms | Cloud-native agent ecosystems | Open-source, cloud-neutral governance — works on-prem |
JamJet is the runtime safety layer underneath whatever framework you already use.
┌──────────────────────────────────────────────────────────┐
│ Authoring Layer │
│ Python SDK | Java SDK | Go SDK (planned) | YAML │
├──────────────────────────────────────────────────────────┤
│ Compilation / Validation │
│ Graph IR | Schema | Policy lint │
├────────────────────────────┬─────────────────────────────┤
│ Rust Runtime Core │ Protocol Layer │
│ Scheduler | State SM │ MCP Client | MCP Server │
│ Event log | Snapshots │ A2A Client | A2A Server │
│ Workers | Timers │ │
├────────────────────────────┴─────────────────────────────┤
│ Enterprise Services │
│ Policy | Audit | PII Redaction | OAuth | mTLS │
├──────────────────────────────────────────────────────────┤
│ Runtime Services │
│ Model Adapters | Tool Execution | Engram Memory │
├──────────────────────────────────────────────────────────┤
│ Storage │
│ Postgres (production) | SQLite (local) │
└──────────────────────────────────────────────────────────┘
JamJet works with your existing AI framework. Browse community-built
integrations for LangChain, LlamaIndex, CrewAI, AutoGen, Pydantic-AI, DSPy,
Spring AI, and LangChain4j → jamjet-labs/jamjet-examples/integrations.
Want to build the official integration for your framework? Claim a slot — first 10 merged contributors get JamJet swag.
Recommended starting points:
| Example | What it shows |
|---|---|
| hitl-approval | Human approval as a first-class workflow primitive |
| coordinator-routing | Dynamic agent routing with structured scoring |
| claims-processing | Insurance pipeline — 4 specialist agents + HITL + audit |
| eval-harness | Batch evaluation with LLM judge scoring |
| mcp-tool-consumer | Connect to external MCP tool servers |
→ All 19 examples · Community integrations · Build your own
| Phase | Status | Goal |
|---|---|---|
| 0 — Architecture & RFCs | ✅ Complete | Design docs, RFCs, repo scaffolding |
| 1 — Minimal Viable Runtime | ✅ Complete | Local durable execution, MCP client, agent cards |
| 2 — Production Core | ✅ Complete | Distributed workers, MCP server, A2A client + server |
| 3 — Developer Delight | 🔄 In Progress | Eval harness, |
| 4 — Enterprise | 🔄 In Progress | Policy engine, tenant isolation, PII redaction, OAuth, mTLS |
| 5 — Scale & Ecosystem | 📋 Planned | Go SDK, TypeScript SDK, hosted plane, marketplace |
Full docs at jamjet.dev
Quickstart · Concepts · Python SDK · Java SDK · YAML Workflows · REST API · MCP · A2A · Eval · Enterprise · Observability · CLI · Deployment
jamjet/
├── runtime/ # Rust workspace
│ ├── core/ # Graph IR, node types, state machine
│ ├── scheduler/ # Durable task scheduler
│ ├── state/ # Event-sourced state, snapshots
│ ├── workers/ # Node executors (model, tool, eval, …)
│ ├── api/ # REST API, OAuth delegation
│ ├── engram/ # Durable memory library (crates.io)
│ ├── engram-server/ # MCP + REST memory server
│ ├── protocols/ # MCP + A2A client/server
│ └── ... # agents, models, timers, policy, audit, telemetry
├── sdk/
│ ├── python/ # Python SDK + CLI (PyPI)
│ ├── java/ # Java SDK (Maven Central)
│ └── go/ # Go SDK (planned)
└── examples/ # 19 runnable examples
Contributions welcome — see CONTRIBUTING.md.
Looking for a starter task?
- Build a framework integration — 8 slots open, first 10 contributors get JamJet swag
- Browse good first issues
- Join the conversation in Discord
GitHub Discussions · Issues · Discord
Apache 2.0 — see LICENSE.
Built by Sunil Prakash · © 2026 JamJet Labs · jamjet.dev · Apache 2.0