← Back to directory
G

GraphARC

Community
Framework / SDK
The admission gate for agent graphs, built on LangGraph

This is a framework for building MCP servers or agents, not a server you connect a client to.

Category
Dev Tools #108 of 438
Stars
★ 84 Popular
Transport
stdio (local process)
Runtime
Python 3.12+
Credentials
Optional API key
License
MIT
Last commit
61FMRS · C

GraphARC (version 0.1.7, MIT licence) is a governed multi-node graph runtime built on LangGraph whose core claim is the admission gate: graphs are proposed at runtime and a deterministic checker admits or refuses them with reasons based on registry, policy, remaining budget, depth and acyclicity, and only admitted graphs execute. It emphasizes worst-case pricing before a run plus per-node billing after, a single replayable JSONL trace, and a supervised Slack flow where execution starts only after a human approves. The default backend drives the claude CLI on your PATH with no API key, with openrouter, openai, ollama and server backends as extras. The README documents its edges: arguments are validated only when a kind declares an args_schema, the in-process sandbox is defense in depth with unconfined run_command children, the HTTP API lacks the durable session layer, agent nodes on the Claude CLI backend are delegated rather than governed, the tool plane still reads CLI flags, and the MCP gate binds the MCP surface rather than the host. It suits teams needing deterministic admission and auditable cost control, and is not for those treating it as a general personal assistant or expecting undeclared full sandboxing and argument governance.

Strongest · Documentation 15/20 Weakest · Reliability 10/20

Reliability
10/20
Security and permissions
10/20
Maintenance
14/20
Documentation
15/20
Setup experience
12/20
Why each score
Reliability 10/20
Static evidence: the README claims tests/test_readme.py executes both code blocks on every commit and shows a CI badge pointing at actions/workflows/ci.yml; the project offers a free deterministic rehearsal (grapharc plan --scripted), trace-based replay (grapharc replay <trace> <run-id>), and per-node cost accounting, indicating deliberate design for reproducibility and diagnosability. However, no SERVER MANIFEST was cached, and the repository root supplies no verifiable MCP server declaration (no tool list, no schemas, no transport config, no stdio/HTTP launch command), so neither the MCP init/tool-list handshake nor declared-vs-real tool behavior can be confirmed. Deductions: the MCP entrypoint and tool contract are entirely absent; the self-reported test execution and CI are uncached self-claims and the README is untrusted evidence by rule; the Limits section itself admits the HTTP API does not yet use the durable session layer, that on the Claude CLI backend an agent node is 'delegated' rather than governed, and that the bypass tier has no checks at all — known unclosed reliability gaps. Structured rejection feedback and fail-closed budgets show error handling exists conceptually, but no verifiable error-code table or troubleshooting guide is present. Static calibration forbids >12 without committed CI workflows plus tests covering the server's key paths; scored 10.
Security and permissions 10/20
Static evidence: by design a deterministic admission gate (registry, policy, remaining budget, depth, acyclicity) sits between proposing and running, and unadmitted steps never execute; the Slack integration unconditionally appends --approve to --go so the run parks before its first node pending a human click, with the button bound to the plan fingerprint so a superseded proposal is refused rather than honoured; the tool plane uses DENY/ASK/ALLOW edge rules with an unmatched-default deny; budgets are worst-case priced before a run. No malware, credential theft, covert exfiltration, fabricated maintainer identity, or real tokens in install examples were found. Deductions, all self-disclosed in Limits: (1) the in-process sandbox is only defense in depth while ContainerExecutor is the real boundary, and run_command children are unconfined; (2) the MCP gate binds the MCP surface, not the host — an agent with its own file tools in the run directory could forge the approval decision, so the trust boundary is the working directory; (3) the Claude CLI bypass tier, explicitly opted into, has no checks at all. Credential handling is described only at the backend level (claude CLI / OpenRouter / OpenAI / Ollama), with no statement on secret storage, redaction, or log filtering; destructive kinds (e.g. deploy) rely on policy configuration rather than built-in hard constraints. These are disclosed but unclosed permission and boundary gaps; no red line (no unconfirmed irreversible deploy/pay/remote-command default) is present, so this is not scored 0-4. Scored 10.
Maintenance 14/20
Static evidence: MIT license is explicit; CHANGELOG.md and ROADMAP.md exist; version 0.1.7 is released on PyPI with a download badge; a GitHub Actions CI workflow exists; the repository is not archived; 69 stars and 13 open issues show external usage with publicly tracked problems; the release cadence read from the description indicates active maintenance. Deductions: issue response latency, dependency-update policy (e.g. Dependabot), and a security-response channel (SECURITY.md or private disclosure process) do not appear anywhere in the supplied material; governance and ownership are limited to an org name, with no maintainer list or release-authority statement; at 0.1.x the API stability is uncommitted. This fits the 'active but governance/versioning gaps' band, scored 14.
Documentation 15/20
Static evidence: docs are layered — the README covers install, quick start, a runnable direct graph-building example, the admission-gate example, the Slack supervised flow, and a comparison table against Claude Code/OpenClaw/raw LangGraph; separate docs/deep-dive.md, docs/cookbook/ (including 07-slack.md), docs/demo/ (stating per-recording what is and is not staged), bench/ with raw logs, CHANGELOG, ROADMAP, and a project website exist; the two README Python blocks are claimed to be executed by tests/test_readme.py on every commit to prevent drift (unverified); the Limits section lists limitations one by one with the most severe first; recordings (gif/mp4) are labeled for staging, giving reviewable evidence. Deductions: MCP-server-level documentation is missing entirely — no tool parameter descriptions, no MCP init/auth flow, no MCP client configuration example, no per-tool failure modes or troubleshooting section; cost and budgeting are conceptual with no concrete billing-example detail; the 'end to end implementation of Graph Engineering' claim lacks an alignment mapping to the referenced proposal. Usable but with hidden assumptions and troubleshooting gaps, scored 15.
Setup experience 12/20
Static evidence: the install path is short and explicit — pip install grapharc (Python >= 3.12), and grapharc demo stage0 costs nothing and needs no key; backends are split as extras (openrouter/openai/ollama/server/all); the default backend drives the claude CLI on PATH, usable with a subscription instead of an API key; grapharc start, grapharc init, and grapharc serve provide a guided tour, scaffolding, and a local browser view, with concrete copy-pasteable commands. Deductions: no configuration sample for any mainstream MCP client is provided (no claude_desktop_config.json or equivalent, no transport or launch-entrypoint description), and with no cached SERVER MANIFEST in the repository root there is no way to confirm how to attach this server to a client; the Python 3.12+ floor is high; the Slack flow needs additional workspace and bot configuration; backend choice and the presence of claude CLI on PATH are implicit prerequisites with no prerequisite check or troubleshooting given. Static calibration caps setup at 15 absent file-level execution evidence; scored 12.

Static review · not runListed 2026-09-10

Read the FMRS scoring method →

Fit and risk

What it can accessWrites / deletes local filesRuns commands or codeUses the network

Best for

  • Teams that need agent workflows under deterministic admission and policy constraints
  • Scenarios requiring worst-case pricing before execution and per-node cost attribution after
  • Compliance or investigation workflows needing one replayable audit trace where the dashboard and the audit trail are the same file
  • Organizations that want a human to press a button before execution starts, for example from Slack
  • Developers who want deterministic, reproducible demos and tests on any checkout via `--scripted`

Not for

  • Those who only need an interactive single-agent loop without pre-execution authorization
  • Anyone looking for a general personal AI assistant gateway or a tool configured by allowlists
  • Users expecting node arguments to be fully validated: admission authorises a node's kind, arguments are checked only where the kind declares an args_schema, and a schema bounds their shape, not what a factory lets them reach
  • Scenarios requiring the HTTP API to use a durable session layer, or the tool plane to be governed by policy documents instead of CLI flags
  • Users who need agent nodes on the Claude CLI backend to be fully governed: by default they run under an allowlist mapped from the node's own tools, but enforcement there is Claude Code's, and the explicit bypass tier has no checks at all

Required permissions

  • The default backend drives the claude CLI on your PATH (a Claude subscription, no API key)
  • Node bodies come from the registry, never from a proposal; the registry is the source of the kinds a planner may propose
  • Policy decides what the planner is able to propose: a denied edge changes the shape of the graph rather than producing a refusal to retry
  • The MCP gate binds the MCP surface, not the host: an agent with its own file tools in the run directory could forge the approval decision, and the trust boundary is the working directory
  • run_command children are unconfined
  • ContainerExecutor is the real boundary; the in-process sandbox is defense in depth

Risks and side effects

  • Admission authorises a node's kind; arguments are validated only where the kind declares an args_schema, and a schema bounds their shape rather than what a factory lets them reach
  • The in-process sandbox is defense in depth, run_command children are unconfined, and ContainerExecutor is the real boundary when explicitly used
  • The HTTP API does not yet use the durable session layer
  • On the Claude CLI backend an agent node is delegated, not governed: by default it runs under an allowlist mapped from the node's own tools, but enforcement is Claude Code's, and the bypass tier has no checks at all
  • Policy documents govern planning while the tool plane still reads CLI flags
  • The MCP gate binds the MCP surface, not the host: an agent with its own file tools in the run directory could forge the approval decision; the trust boundary is the working directory, as it is for the Slack workspace

Setup

Before you start

Runtime:Python 3.12+

Requires Python 3.12 or newer.

  1. Install with pip install grapharc.
  2. Verify with grapharc demo stage0: it costs nothing and needs no key.
  3. Run grapharc start for the guided tour.
  4. Run grapharc init to scaffold registry.py and grapharc.toml.
  5. Optional: install backend extras grapharc[openrouter], grapharc[openai], grapharc[ollama], grapharc[server] or grapharc[all]; the default backend drives the claude CLI on your PATH.
  6. Propose and save a plan with grapharc plan "..." --model ollama/qwen3:8b, then execute with grapharc go; grapharc plan "..." --scripted is a free rehearsal with no AI involved.
  7. Watch runs live with grapharc serve --live-root .grapharc/runs, and reconstruct a run with grapharc replay <trace> <run-id>.

Check that it works

Run `pip install grapharc` then `grapharc demo stage0`; if the demo completes without needing any API key, the install works.

Troubleshooting

  1. Confirm Python is 3.12 or newer, otherwise the pip install will fail
  2. Verify first with `grapharc demo stage0` and `grapharc plan "..." --scripted`: both are free and need no key, which rules out model and credential problems
  3. If planning is repeatedly rejected, read the structured rejection feedback codes (for example edge_denied); the planner replans against them
  4. The default backend needs the claude CLI on your PATH; install the matching extra (openrouter, openai, ollama, server, all) to use another backend
  5. Check configuration from the run output: it prints goal, model, registry, kinds, policy and config (whether grapharc.toml was read)
  6. To review a run, use `grapharc replay <trace> <run-id>` to reconstruct it from its trace; the dashboard and the audit trail are the same file
  7. Examples on the page are executed by tests/test_readme.py against every commit, so use that to locate drift if the docs and code disagree

Use cases

Propose a graph of work at runtime and have a deterministic admission checker admit it or refuse it with reasons
Price the worst case before a run and bill per node after, with fail-closed cost control
Keep one replayable JSONL trace per run and reconstruct runs from it
Ask for work from Slack, get the proposed graph plus Approve/Deny buttons, and let a human start execution
Rehearse planning and admission for free and deterministically with `--scripted`, no AI or key needed
Compare success, cost, wall time and policy violations against third-party agents on the same tasks

Overview

GraphARC is a governed multi-node graph runtime built on LangGraph. A model proposes a graph of work at runtime; a deterministic checker covering the registry, policy, remaining budget, depth and acyclicity admits it or refuses it with reasons; only admitted graphs execute, under budgets, onto one replayable JSONL trace. No step runs unadmitted, the worst case is priced before a run and billed per node after, and the dashboard cannot disagree with the audit trail because they are the same file. It ships CLI commands (start, init, plan, go, serve, replay, demo), a Python API for building graphs directly with typed state, declared writes and a required budget, and a supervised Claude Code workflow from Slack where the bot replies with the proposed graph plus Approve/Deny buttons and nothing executes until a human presses one. The default backend drives the claude CLI on your PATH (a Claude subscription, no API key), with openrouter, openai, ollama and server backends as extras.

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 63.3k · Tools 2 Compare with this →

Source revision e27b9e8b55af Data synced 2026-10-19 Read the FMRS scoring method