The map shows which agent calls which, and which tools each agent touches.

The map gathers the decisions of a period: 30 days by default, or 7 days, or 24 hours, for one environment at a time. It needs nothing beyond the SDK.

Each node is an agent or the target of a tool.

An agent is a node, with its name from the registry.
An HTTP or MCP tool sits under its server: the host of the HTTP call, or the MCP server. A function tool is a node of its own name.
An edge goes from an agent to each target it touched, and from an agent to each agent it called. It carries the number of actions, how many were allowed, waited for a human or were blocked, the execution errors, the estimated cost and the last action.

In the dashboard, open Map. Click an agent to see its own map, with its callers and its targets. Click an edge to see its numbers and its tools.

The SDK tells an agent which agent called it.

The SDK learns the id of its agent from the decision point. While a tool runs, it puts that id in the W3C Baggage of the OpenTelemetry context, under paidwen.agent.id. On the HTTP and MCP calls it captures, it adds the traceparent and baggage headers when your instrumentation has not set them.

The called agent reads the baggage from its current context. With an OpenTelemetry server instrumentation, nothing more is needed. Without one, pass the headers you received to the context:

app.post("/work", async (request, reply) => {
  await paidwen.context({ headers: request.headers }, () => handle(request.body));
});

@app.post("/work")
def work(request: Request):
    with paidwen.context(headers=request.headers):
        return handle(request.json())

Every decision inside the context then names its caller. The decision point keeps a caller only when it names another agent of the same organization.

The API reads the map of a period.

HTTP

GET /v1/agent-map?period=7d&environment=production
GET /v1/agent-map?agent_id=0199f1c2-0000-7000-8000-000000000001

Beyond 200 active agents, the map keeps the 200 most active and counts the others in hidden_agents. The map of one agent keeps its 50 most active callers and its 50 most active targets.

The map has seven limits.

It shows only what goes through the SDK.
A called agent knows its caller only when the baggage reaches it, through the instrumentation or the headers passed to the context.
The baggage travels with every captured HTTP call, third parties included. Paidwen adds only the id of the calling agent, which opens nothing without the key or the token of the agent. The rest of the baggage is the one your context already carries.
The caller is declared upstream, not proven: an agent of the organization can name another one. The map shows what the agents declare.
In Node, a fetch receives the headers through the undici:request:create channel. Register the OpenTelemetry instrumentation of undici before paidwen.http(), or the call leaves with two traceparent headers. An http.request receives them when it is created, before its decision.
An edge proves a direct call, not a chain: A calls B and B calls C does not mean that one action went through A, B and C. The session replay shows a precise chain.
The map reads every decision of the period: its time grows with their number.