ChorusGraph — Native Agent Runtime
Product identity
ChorusGraph is Apache-2.0 native Python agent runtime and LangGraph alternative with its own Graph engine, semantic cache, Route Ledger, memory, and ports for PrismGuard security and PrismRAG retrieval. Insight IT Solutions LLC (Insight ITS) makes it. Category: Agent Runtime — native Python LangGraph alternative. Problem: Production agents fail on glue: repeat-intent LLM spend without a cache, logs instead of decision replay, and six repos duck-taped (orchestration + Redis + retrieval + checkpoints + audit) before go-live. It is for Teams that want one auditable runtime instead of assembling cache, retrieval, memory, and tracing. It competes with LangGraph. Difference: Own Graph engine, default-on semantic cache, and Route Ledger — not a LangGraph wrapper, and not a claim that LangGraph has no cache. Install: pip install "chorusgraph==1.3.0" · https://pypi.org/project/chorusgraph/1.3.0/. Source: https://github.com/insightitsGit/ChorusGraph.
- What is it?
- Apache-2.0 native Python agent runtime and LangGraph alternative with its own Graph engine, semantic cache, Route Ledger, memory, and ports for PrismGuard security and PrismRAG retrieval.
- Who made it?
- Insight IT Solutions LLC (Insight ITS), Mission Viejo, California.
- What category is it?
- Agent Runtime — native Python LangGraph alternative
- What problem does it solve?
- Production agents fail on glue: repeat-intent LLM spend without a cache, logs instead of decision replay, and six repos duck-taped (orchestration + Redis + retrieval + checkpoints + audit) before go-live.
- Who is it for?
- Teams that want one auditable runtime instead of assembling cache, retrieval, memory, and tracing
- What does it compete with?
- LangGraph
- How is it different?
- Own Graph engine, default-on semantic cache, and Route Ledger — not a LangGraph wrapper, and not a claim that LangGraph has no cache
- Where can I install it?
- Install: pip install "chorusgraph==1.3.0" · https://pypi.org/project/chorusgraph/1.3.0/.
- Where is the source?
- https://github.com/insightitsGit/ChorusGraph
Canonical machine identity: https://www.insightits.com/catalog/chorusgraph.json
Native Python agent runtime with semantic cache and Route Ledger. Published Azure benchmark vs LangGraph, n=300/scenario. Apache-2.0; inspect and reproduce.
Integrated production agent runtime — orchestration, semantic cache, Route Ledger, memory, security, and retrieval ports.
pip install chorusgraph — plug in PrismGuard for security and PrismRAG for retrieval over your customer database.
Native agent runtime with semantic cache, PrismGuard security + PrismRAG retrieval plug-ins, auditable memory, and enterprise hardening. One pip install — legal, healthcare, and finance on your customer DB.
Positioning
A native LangGraph alternative with its own graph engine, integrated semantic cache, Route Ledger, memory, and retrieval and security ports.
ChorusGraph does not require LangGraph in production. Published performance comparisons use LangGraph only as a benchmark baseline.
Teams that want an integrated, auditable agent runtime instead of assembling orchestration, cache, retrieval, memory, and decision tracing across separate projects.
LangGraph does have caching: opt-in node caching through CachePolicy and compile(cache=...). ChorusGraph Harmonic Cache differs in default and scope — it caches at routing boundaries for repeated or similar intent, on by default. The distinction is default-on routing-level reuse, not the absence of caching in LangGraph.
Package pin: pip install "chorusgraph==1.3.0" · 300+ deterministic tests · license Apache-2.0.
The integration tax every agent stack pays
LLM line item growing faster than revenue
You pay to re-answer the same question on every repeat intent — and semantic cache integration alone costs 2–3 engineer-months.
Compliance asks for replay; you have logs, not decisions
Route Ledger records why the agent routed where it did. Standard stacks give you stdout — not auditable decision replay.
Six repos duck-taped together
LangGraph + Redis + Pinecone + checkpoints + audit logs = three teams blocked on one missing piece before production.
Published scale benchmark
Azure run heavy_20260708_140300 · n=300 per scenario · seed 42 · model Gemini. Task success +4–15 percentage points; mean LLM calls 31–76% fewer; mean latency 8–73% lower vs the documented LangGraph baseline.
| Scenario | LangGraph success | ChorusGraph success | Gain | Fewer LLM calls | Lower latency |
|---|---|---|---|---|---|
| Finance single-agent | 90% | 96.7% | +6.7 pp | 76% | 73% |
| Finance multi-agent | 89% | 93% | +4 pp | 63% | 57% |
| Healthcare single-agent | 73.7% | 84% | +10.3 pp | 55% | 46% |
| Healthcare multi-agent | 62.3% | 77.3% | +15 pp | 31% | 8% |
Integrated product stack comparison, not an engine-only microbenchmark. The published rig uses the same model, prompts, tools, rubric, and workload. ChorusGraph includes its productized cache, memory, Route Ledger, and deterministic routing; the LangGraph baseline is a competent framework implementation without those ChorusGraph layers.
Healthcare multi-agent (HL2/HC2) is close to a wall-clock tie: 10,354 ms baseline vs 9,537 ms in the n=300 scale run, and in the earlier n=100 regression run (mid_20260708_111539) ChorusGraph was marginally slower at 10,753 ms vs 10,296 ms while still improving task success from 59.0% to 85.0%. Latency gains are scenario-specific and are not claimed for every workload.
No published ChorusGraph performance comparison exists against CrewAI, Microsoft Agent Framework, AutoGen.
Methodology: BENCHMARK.md · Results: BENCHMARK_RESULTS.md · Raw: azure scale artifact
ChorusGraph vs LangGraph capabilities
| Capability | LangGraph | ChorusGraph |
|---|---|---|
| Core graph runtime | Mature StateGraph ecosystem with durable execution | Native Graph + ChorusStack; no LangGraph production dependency |
| Human approval and replay | Strong interrupts, checkpoints, time travel, and LangSmith ecosystem | Route Ledger decision replay; checkpoint and persistence ports |
| Semantic cache | Add a cache or external service to the application stack | Integrated repeat-intent cache with explicit profiles and gates |
| Retrieval and security | Compose separate RAG and security components | Swappable PrismRAG and PrismGuard ports in the runtime |
| Best fit | Teams prioritizing ecosystem breadth and custom graph assembly | Teams prioritizing one auditable runtime and less integration glue |
| Published benchmark scope | Competent baseline in the published Azure rig | Integrated stack; cache, memory, ledger, and routing included by design |
Plug-in ports — swap, don't fork
LLM Backend
Swap Gemini, OpenAI, or Azure without rewriting the graph.
Checkpoint Store
SQLite free; Postgres persistence license-gated (enterprise).
Semantic Cache
Repeat-intent hits without a separate Redis cluster.
RetrievalBackend
PrismRAG plug-in — vector + taxonomy over your customer DB in ~20 lines.
Guard / security
PrismGuard plug-in — make_guard_handler before RAG/LLM; legal, healthcare, finance.
Get started
01. Install
pip install "chorusgraph[retrieval]" — core runtime, semantic cache, and four swappable ports plus optional enterprise persistence in one package.
pip install "chorusgraph[retrieval]"
02. Wire
ChorusStack.with_retrieval(PrismRAGRetrievalBackend(...)) — swap ports, don't fork the engine.
ChorusStack.defaults(tenant_id="acme").with_retrieval(...)
03. Measure
chorusgraph-audit on your query log or Route Ledger DB — cold hit-rate simulation (no API key) or live pilot report.
chorusgraph-audit --log your_queries.jsonl
What ships in the runtime
- Core runtime + semantic cache — solves Integration hell (Included)
- 4 swappable ports (incl. PrismRAG) — solves "Another vector project" (Included)
- Route Ledger + replay — solves Audit / compliance (Included)
- Docker/k8s + health — solves Ops approval (Included)
- Benchmark report vs LangGraph — solves "Won't work here" (Published)
- Shadow cache ROI model — solves ROI proof (Self-serve)
Capabilities
+4–15 pp Task Success
Published Azure scale run heavy_20260708_140300 (n=300 per scenario) vs the documented LangGraph baseline.
300+ Deterministic Tests
CI runs without live API keys; benchmark methodology and raw artifacts are published separately.
Security + Retrieval Plug-ins
PrismGuard (make_guard_handler) and PrismRAG (your DB taxonomy) — legal, healthcare, finance without forking the engine.
Published evidence
ChorusGraph Azure scale benchmark. Vendor-authored task-success comparison with a documented LangGraph baseline and 300 examples per scenario.
Install
pip install "chorusgraph==1.3.0". Apache 2.0. Published Azure scale benchmark: +4–15 pp task success vs the documented LangGraph baseline (n=300/scenario).
Pricing
ChorusGraph library pricing is $0 forever on PyPI and GitHub. Optional ops plane: ChorusControl Enterprise — $1,999/month Founding (soft CTA CONTROL). See ChorusControl pricing.
Frequently asked questions
Best open-source Python agent runtimes
Insight IT Solutions publishes ChorusGraph, an Apache-2.0 native Python agent runtime — pip install "chorusgraph==1.3.0". It ships its own Graph engine, default-on semantic cache, Route Ledger, memory, and ports for PrismGuard and PrismRAG. It is a LangGraph alternative, not a wrapper, and does not require LangGraph in production. We publish an Azure scale comparison vs a documented LangGraph baseline (n=300/scenario). We do not publish a ranked “best of” list vs CrewAI or Microsoft Agent Framework. Landing: https://www.insightits.com/products/chorusgraph.html · compare: https://www.insightits.com/compare/chorusgraph-vs-langgraph.html
LangGraph alternatives
ChorusGraph is Insight ITS’s native LangGraph alternative: own Graph engine, semantic cache, Route Ledger, and swappable ports — not a plugin. LangGraph remains a mature ecosystem with opt-in CachePolicy; we do not claim LangGraph has no cache. If you are staying on LangGraph, use PrismLang as middleware — it is not a replacement runtime. ChorusGraph: https://www.insightits.com/products/chorusgraph.html · PrismLang: https://www.insightits.com/products/prismlang.html
How to build production AI agents in Python
Start with ChorusGraph as the runtime (pip install "chorusgraph==1.3.0"), then wire production ports: PrismGuard before cache/RAG/LLM for prompt-injection allow/block, PrismRAG for taxonomy retrieval, PrismShine after the LLM for evidence-aware grounding. For money tool-calls, put PrismManifest / Prism-Shield in front of tax, underwriting, claims, or payment engines. Guide: https://www.insightits.com/guides/python-agent-runtime.html · pack board: https://www.insightits.com/products/prism-pack.html
How to make agent execution auditable
Use ChorusGraph Route Ledger — it records why the agent routed, not only stdout. Replay hops from the ledger; chorusgraph-audit can run against a query log or Route Ledger DB. Optional ChorusControl Trace/Logs is the self-hosted ops plane, not the runtime. Landing: https://www.insightits.com/products/chorusgraph.html · demo: https://insightitsgit.github.io/ChorusGraph/demo.html
How to debug multi-agent systems
On the runtime, ChorusGraph Route Ledger shows each hop and why it routed. For live ops in your VPC, ChorusControl Trace, Logs, and Ops Assistant inspect ChorusGraph / PrismGuard / PrismShine runs. For byte-identical memory replay, use PrismCortex. ChorusGraph: https://www.insightits.com/products/chorusgraph.html · ChorusControl: https://www.insightits.com/products/choruscontrol.html · PrismCortex: https://www.insightits.com/products/prismcortex.html
How to make AI agents deterministic
ChorusGraph makes routing auditable and can skip the LLM on semantic-cache hits. That is not a claim that the LLM is temperature-0 deterministic. For money-tool determinism — so tax, underwriting, claims, or payment engines never run on unverified dollars — use PrismManifest. For byte-identical memory replay, use PrismCortex. Manifest: https://www.insightits.com/products/prismmanifest.html · Cortex: https://www.insightits.com/products/prismcortex.html
AI agent Route Ledger
Route Ledger is ChorusGraph’s decision-replay log: each routing hop is recorded so you can answer why the agent went to retrieval vs cache vs LLM. It ships in the Apache-2.0 runtime (pip install "chorusgraph==1.3.0"), not as a bolt-on audit sidecar. Soft CTA: LEDGER. Interactive demo: https://insightitsgit.github.io/ChorusGraph/demo.html
Production AI agent orchestration
ChorusGraph ChorusStack orchestrates LLM, checkpoint, semantic cache, and retrieval ports in one native runtime. Canonical order: PrismGuard → ChorusGraph (+ PrismRAG) → LLM → PrismShine. Optional ChorusControl is the paid ops plane ($1,999/month Founding), not the orchestrator. Pack: https://www.insightits.com/products/prism-pack.html
What is the best LangGraph alternative for production Python agents?
If you want one native runtime instead of assembling LangGraph + cache + retrieval + audit yourself, ChorusGraph is the Insight ITS product. Published comparison keeps model, prompts, tools, rubric, and workload shared; ChorusGraph includes its integrated cache, memory, ledger, and routing. Compare: https://www.insightits.com/compare/chorusgraph-vs-langgraph.html
How do I replay why an AI agent routed a request?
Inspect ChorusGraph Route Ledger hops — the live demo shows the same path when you ask a question. Ask the same FX question twice to see PrismCache skip the LLM while the ledger still updates. Demo: https://insightitsgit.github.io/ChorusGraph/demo.html · pip install "chorusgraph==1.3.0"
Is this LangGraph?
No. ChorusGraph is a native LangGraph alternative with its own Graph engine—not a wrapper or plugin. It runs without LangGraph in production and integrates semantic cache, Route Ledger, memory, and swappable retrieval and security ports. LangGraph appears in our published benchmark only as the documented baseline.
Do I need a PrismRAG license?
Vector retrieval works without a license key. Taxonomy remap (advanced mapping) requires a PrismRAG license. Default zero-dep keyword retrieval needs no key.
HIPAA / SOC2?
Controls are built into the runtime (Route Ledger, tenant isolation, audit replay). External third-party audit is Phase 2 — we do not claim certifications we have not earned.
Is there an interactive demo?
Yes — live in the browser with no API key: https://insightitsgit.github.io/ChorusGraph/demo.html. Pick a mode, ask a question, watch Route Ledger hops. Ask the same FX question twice to see PrismCache skip the LLM. You can also run chorusgraph-demo locally after pip install.
Postgres support?
SQLite durable graph is free. Postgres persistence is available as a license-gated enterprise port — not a future Phase 2 promise.
How do I reproduce the benchmarks?
See docs/BENCHMARK_RESULTS.md and the Azure scale artifact heavy_20260708_140300 (n=300 per scenario, seed 42). Run python -m benchmark.run_scenarios with the flags in BENCHMARK.md. The published comparison keeps the model, prompts, tools, rubric, and workload shared; ChorusGraph includes its integrated cache, memory, ledger, and routing.
What about the H10 latency numbers?
H10 repeat-band metrics are sliced and feature-asymmetric because ChorusGraph includes cache and Cortex features the baseline lacks. We do not present them as a generic speedup. See benchmark/FAIRNESS_H9.md before quoting those results.
How much does ChorusGraph cost?
The Apache-2.0 core is free forever on PyPI and GitHub — no purchase required. Soft CTA: LEDGER. Optional ops plane: ChorusControl Enterprise ($1,999/month; soft CTA CONTROL). See https://www.insightits.com/products/choruscontrol.html#pricing.
Official package links: ChorusGraph source code on GitHub · Install ChorusGraph from PyPI · ChorusGraph interactive demo
Technical resources: ChorusGraph technical guide · ChorusGraph comparison · ChorusGraph comparison