Roster for LangGraph

Add live organizational context to stateful agents.

Connect LangGraph to Roster so agents can resolve who owns, approves, reviews, handles, or receives an escalation without hard-coding people into graph logic.

LangGraph controls how the agent proceeds. Roster resolves who should act.

Connect Roster to LangGraph Read the Roster MCP documentation

Last verified 07/14/2026

Organizational decisions do not belong in graph code

LangGraph gives developers low-level control over state, branching, durable execution, and human-in-the-loop steps.

But the graph still needs a current answer when a node reaches a person-dependent decision:

“Who owns this service?”

“Who can approve this request in Canada?”

“Who reviews a change above this threshold?”

“Who should receive this escalation?”

“Who is covering for the normal approver?”

Embedding names, email addresses, or static org-chart logic in nodes makes the graph brittle. The answer may depend on project membership, business role, geography, directory state, labels, or an active delegation. Roster keeps that organizational context outside the graph and exposes participant resolution as a reusable runtime tool.

How Roster fits into a LangGraph agent

LangGraph agents can consume MCP tools through the LangChain MCP adapters package. Roster is configured as a remote Streamable HTTP MCP server.

LangGraph agent or workflow
        ↓
LangChain MCP adapter
        ↓
Roster Streamable HTTP MCP server
        ↓
Project + participant model
        ↓
Directory users, groups, roles, memberships, and delegations
        ↓
Resolved owner, approver, reviewer, or escalation contact

What LangGraph agents can resolve

Human approval nodes

Select the current participant for a human-in-the-loop checkpoint before the graph pauses or creates an approval task.

“Who should approve this production change?”

Dynamic task ownership

Assign a task using current project ownership instead of a name stored in graph state or application code.

“Who owns customer onboarding for the North America project?”

Review routing

Resolve the right technical, security, legal, or business reviewer from the context accumulated by the graph.

“Who should review this authentication change?”

Escalation branches

Choose the correct escalation contact when a timeout, exception, confidence threshold, or business rule sends execution down an escalation path.

“Who receives a severity-one escalation for Atlas?”

Multi-agent handoffs

Determine the human owner or accountable group when one agent must hand work to another team or leave the agent system.

“Which participant should take over after the research agent flags a compliance issue?”

Delegated coverage

Return the active delegate when the normal participant is unavailable.

“Who is covering for the release approver today?”

Connect Roster to LangGraph

LangGraph agents can consume MCP tools through the LangChain MCP adapters package. Configure Roster as a remote HTTP server and pass a scoped bearer token through headers.

pip install langchain-mcp-adapters

import os
from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient(
    {
        "roster": {
            "transport": "http",
            "url": "https://roster.example.com/mcp",
            "headers": {
                "Authorization": f"Bearer {os.environ['ROSTER_API_KEY']}"
            },
        }
    }
)

roster_tools = await client.get_tools()

Add the returned Roster tools to the agent that needs participant resolution. The API key requires mcp:resolve to call resolve. Add mcp:resolve-requests:read, mcp:projects:read, or mcp:participants:read only when the agent also needs those read surfaces. Effective access remains limited by the key owner's Roster permissions and resource rules.

Resolve-only automation scope

For resolve-only workflows, use narrow scopes. The key belongs to a Roster identity and remains constrained by that identity's Roster permissions and target-resource rules.

mcp:resolve
mcp:resolve-requests:read
mcp:projects:read
mcp:participants:read

Make resolution an explicit graph step

For predictable behavior, add a dedicated node that calls Roster when the workflow reaches an ownership, approval, review, or escalation decision. Store the structured result in graph state, then route based on the outcome.

Recommended states:

- resolved participant found
- no eligible participant found
- out_of_scope or no eligible participant returned
- authorization failure
- Roster unavailable

Do not silently fall back to a name inferred from the
prompt, repository, or model memory.

Example: route a production approval

A release graph reaches its approval node with the project, environment, risk level, and requested deployment time in state.

“Who should approve the Atlas production deployment?”

The node calls Roster:

resolve(
  query: "Who should approve the Atlas production deployment?"
)

Roster evaluates the applicable project, participant definition, labels and metadata, directory membership, active status, and delegations.
The graph stores the resolved participant and creates the approval task.
If no eligible participant is returned, the graph enters an explicit exception path instead of guessing.

The graph continues along its resolved branch, or along a defined exception branch when Roster returns no eligible participant.

Roster complements LangGraph

LangGraph remains responsible for agent state, control flow, persistence, checkpoints, tool execution, and human-in-the-loop orchestration.

Roster provides the organizational decision layer used when that graph needs a person, group, role, or delegate. It does not replace LangGraph state, routing logic, or execution infrastructure.

Security and governance

Identity attribution

Give each deployed agent or service account its own Roster identity.

Least privilege

Grant mcp:resolve for participant resolution. Add only the specific mcp:* read scopes required for project, participant, delegation, label, or Resolve-history lookup.

Project boundaries

MCP access does not bypass Roster's project and resource-level authorization.

Secret handling

Load API keys from environment variables or a secret manager. Do not commit them in graph code or configuration.

Explicit failure handling

Model no result, out-of-scope, authorization failure, and service failure as graph states.

Auditable requests

Use Resolve Requests to inspect the recorded resolution status, actor, project, query, and result counts visible to the acting identity.

Frequently asked questions

Roster is exposed as a remote MCP server. LangGraph applications can load its tools through the LangChain MCP adapters package and call them from an agent or a dedicated graph node.

Add current organizational context to your LangGraph agents

Keep graph logic focused on execution while Roster resolves the people, groups, roles, and delegates responsible for what happens next.

Connect Roster to LangGraph Read the Roster MCP documentation Explore all integrations