Skip to content
Agentic Control Plane

Govern LangGraph with Agentic Control Plane

LangGraph is the de-facto framework for production multi-agent systems on top of LangChain. The supervisor-and-workers pattern is the reference architecture — and it maps perfectly onto ACP’s delegation chain primitives.

TL;DR — Path 2 (works today)

Route LangGraph’s LLM through ACP:

from langchain_openai import ChatOpenAI
import os

governed = ChatOpenAI(
    base_url="https://api.agenticcontrolplane.com/v1",
    api_key=os.environ["ACP_API_KEY"],
    model="claude-sonnet-4-6",
)

Use governed as the LLM in any node. Every LLM call and the tool calls they emit are audited.

TL;DR — Path 3 (full A2A attribution)

The native Python adapter (acp-governance-langchain, scaffolded) maps each graph node to a distinct agent. Each node’s tool calls register with the node’s name; supervisor → worker handoffs become delegation chain links.

from acp_governance_langchain import govern_node

@govern_node(name="researcher")
def researcher(state): ...

@govern_node(name="coder")
def coder(state): ...

Status: Adapter in pre-release. Use Path 2 today; Path 3 for full per-node enforcement when published.

How it works

LangGraph’s runtime calls each node’s function. The adapter wraps each node so:

  1. Before the node runs, ACP checks the node’s policy (allowed tools, scope intersection with parent, remaining budget)
  2. Tool calls inside the node POST to ACP’s governance endpoints
  3. When the node returns and the supervisor routes to the next worker, that handoff registers as a chain link

The supervisor pattern — supervisor → worker → supervisor → next worker — becomes a flat-but-named chain in the audit log. Loops are bounded by ACP’s chain depth limit and budget propagation.

What you’ll see in the dashboard

Each LangGraph node appears as a distinct agent on the Agents page (with the Path 3 adapter). Activity is per-node; delegation chains show supervisor → worker hops with budget remaining at each step.

Limitations

  • Path 2 (OAI proxy) cannot enforce per-node tool restrictions. It sees LLM calls but doesn’t know which node made which one. Path 3 adapter required for per-node enforcement.
  • Path 3 adapter is pre-release and not yet on PyPI.
  • State management is out of scope. ACP doesn’t intercept LangGraph’s checkpointer or state writes. Those remain in your storage backend.
  • Async workflows partially supported. Sync graphs work today; async streaming pending in the adapter.
  • Conditional edges and routing logic live in your graph code, not in ACP. Policy can deny a node from running but cannot rewrite the routing decision.