langport
Download

Debug any agent in real-time.

Point Langport at any AG-UI agent endpoint and watch the whole run unfold: every tool call, every token, every subagent it spawns.

Any runtime
LangGraph AG-UI
CrewAI AG-UI
Vercel AI SDK AI SDK
Next.js route AI SDK
Google ADK OpenAI
Custom agent OpenAI
any ai protocol
adapters
ag-ui SSE · 16 frames
vercel-ai-sdk data stream parts
openai-responses streaming API
no shared schema — each adapter
records the wire as it is
langport live
Trace Terminal Subagents Tools
run 4.2s
plan 0.8s
retrieve 1.1s
tool 0.6s
subagent 1.5s
state delta
+ cart.items[2] · − draft.step
One inspector, protocol-native views — AG-UI rules stay AG-UI rules.
Any runtime
LangGraph
CrewAI
Vercel AI SDK
Next.js route
Google ADK
Custom agent
any ai protocol
adapters
ag-ui SSE · 16 frames
vercel-ai-sdk data stream parts
openai-responses streaming API
no shared schema — each adapter
records the wire as it is
langport live
Trace Terminal Subagents Tools
run 4.2s
plan 0.8s
retrieve 1.1s
tool 0.6s
subagent 1.5s
state delta
+ cart.items[2] · − draft.step
One inspector, protocol-native views — AG-UI rules stay AG-UI rules.
Download for macOS See a live trace
Also on Windows, Linux, and in the browser · free forever
How it works

Three steps to your first trace

no SDK · no instrumentation
01

Paste your endpoint

Any HTTP endpoint that streams SSE or NDJSON. Local, staging, or prod: no agent code changes.

02

Send a run

Type a prompt, hit send, and watch tokens and tool calls arrive in real time.

03

Open the tree

Every subagent it spawned, nested, with its own prompt, steps, and cost. Save it, replay it, share it.

What you get

A workbench, not a log viewer

Everything you'd otherwise wire up by hand (request builder, live stream, replay, diffing) in one place that speaks agent, not HTTP.

Works with any AG-UI agent

Point it at an AG-UI endpoint and the whole run renders: no SDK, no instrumentation, no schema mapping.

Adaptive protocol support coming soon

Live event stream

Deltas, tool calls, and errors land as they happen, with a scrubbable timeline you can rewind.

Replay any run

Re-send a saved run against a new endpoint or prompt and diff the two side by side.

Cost and latency

Per-agent tokens, dollars, and wall time, rolled up the tree, not just the top-level call.

Requires usage events from your agent

Readable transcripts

The run as a conversation, not JSON. Expand any turn into its underlying raw events.

Request builder

Headers, auth, body, and streaming mode. Save requests into collections your team shares.

Up next

Fork and debug

Pause at any step, edit the state, prompt, or tool result, and fork a new run from that point. Compare branches side by side.

Coming soon

Assertions

Pin expectations on a run (tool called, output contains, cost under) and rerun them on every change.

Subagent tracing

When your agent delegates, you can still see everything

Most tools flatten a spawned subagent into a single opaque tool call. Langport reconstructs the tree from the event stream (parent run, child runs, and every hop below), so a nested delegation reads like the conversation it actually was.

Parent linking, however you emit it
parentToolCallId, subagentId, parentRunId: Langport matches on any of them, and orphans still get grouped by the call that spawned them.
Each subagent's own task prompt
See the exact instruction the parent handed down, not just the tool name it used to hand it down.
Rolled-up cost, per branch
Find out which of your six parallel readers is burning 60% of the budget.
Unlimited depth
Subagents that spawn subagents nest cleanly instead of collapsing into a flat list.
Run tree depth 3 · 7 agents
orchestrator
18.4s
plan
2.6s
reader · A
6.1s
extract_terms
3.0s
reader · B
5.4s
reader · C
3.2s
merge_findings
5.1s
Bring your own agent

If it streams events, it works

Langport speaks plain SSE and NDJSON. Emit whatever shape you already emit: it maps tool calls, deltas, and parent ids on the way in. Point it at your agent and hit send.

OpenAI-compatible LangGraph Anthropic SDK CrewAI Gantry (Go) Your own loop
# Nothing to install. Just stream events.

async def run(prompt: str):
    yield sse("token", {"text": "Splitting into 3 readers…"})

    for batch in batches:
        yield sse("tool_call", {
            "id": call_id,
            "name": "spawn_agent",
            "args": {"agent": "reader", "task": batch.prompt},
        })

    # child events carry the parent's call id
    yield sse("token", {
        "text": chunk,
        "parentToolCallId": call_id,
    })

No account. No setup. Just an endpoint.

Download the desktop app, open in browser, or pull the Docker image. Paste an endpoint and send your first run in under a minute.

Download for macOS Open in browser
macOS 13+ · Windows 11 · Linux (.deb, AppImage)
or

No installer, no account either way. Pull the public Docker image and run it anywhere.

shell
docker run -p 3000:80 ghcr.io/langport-dev/langport:latest
Open localhost:3000, point it at any AG-UI endpoint

Questions

No. Langport is a client, not a tracer. If your endpoint streams events over SSE or NDJSON, it can read them. Adding a parent id to child events unlocks the nested tree, but a flat stream still works.
The desktop app talks directly to your endpoint. Runs are stored locally in SQLite. Nothing is sent to us unless you explicitly share a run link.
By spawn-style tool calls (names like delegate, task, spawn_agent, dispatch) or any call whose arguments carry an agent field with a prompt or task. You can edit the matching rules per workspace.
Coming soon. Saved requests and runs will live in a workspace file you can commit to your repo, so reviewing an agent change works like reviewing code.
Nothing. Langport is free, including the desktop app: no paid tiers, no seat limits.