langport
Download

Stop guessing what your agent did

Point Langport at any agent endpoint and watch the whole run unfold — every tool call, every token, every subagent it spawns. Send, inspect, replay.

Download for macOS See a live trace
Also on Windows, Linux, and in the browser · free forever
langport beta
localhost:8080/agui streaming
event 49/49 Go to live
Runs
whats going on with the bu…
3:54:39 PM · running
demo · retention summary
3:08:14 PM · RUN_FINISHED
thread_lpkpe1na running 49 events · 1 subagent
A
That's a broad one — let me narrow it down so I give you something useful.
ok ask_user {"questions": [{"header": "Focus area", "text": "What aspect
data running
15s · 1 tool
What are yesterday's and today's revenue, orders, and AOV (average order value)?
step · llm_call::run-d18d5df29e8e93c5 open full view →
Send a prompt… Stop
Timeline
Subagents 1/1 live
Console
49 events
Show text11 tools7 lifecycle3 steps28 state0 other0
Phase timeline 32.78s total
3.90sTEXT_MESSAGE_CONTENTlet me narrow
3.95sTEXT_MESSAGE_CONTENTI give
4.09sTEXT_MESSAGE_CONTENTuseful.
6.48sTEXT_MESSAGE_END
6.48sSTEP_FINISHED · llm_callllm_call
6.48sSTEP_STARTED · post_llmpost_llm
6.48sTOOL_CALL_START · ask_usercall_e2b7d3275b914dcc
6.48sTOOL_CALL_ARGS{"questions": [{"header": …
30.02sTOOL_CALL_RESULT{"answers":[{"header":"F…
6.48sSTEP_STARTED · tool_exectool_exec
6.48sSTEP_FINISHED · observeobserve
6.48sRUN_FINISHED
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.

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

Request builder

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

Coming soon

Assertions

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

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.

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.

Gantry (Go) OpenAI-compatible LangGraph Anthropic SDK CrewAI Your own loop
// examples/agui/main.go — a Gantry agent over AG-UI.

func newHandler(llm gantry.LLMClient, opts ...agui.Option) (http.Handler, error) {
    agent, err := gantry.NewAgent(gantry.WithLLM(llm))
    if err != nil {
        return nil, err
    }
    // ask_user is a client-side tool: the run suspends,
    // the client answers, the run resumes.
    if err := agent.With(tool.Client(ask.Definition())); err != nil {
        return nil, err
    }
    return agui.Handler(agent, opts...), nil
}

http.Handle("/agui", handler)
// → point Langport at localhost:8080/agui
Compare

Logging tells you what happened. Langport lets you do it again.

Capability
Logging / APM
Langport
See a run while it streams
after the fact
live
Nested subagent tree
one flat span
full depth
Re-send a run with edits
one click
Cost rolled up per branch
per call
per agent
Setup required
SDK + exporter
paste a URL
Fork a run mid-flight
no
edit state, re-run
Assertions and evals
separate harness
pinned to the run

Open your agent up

One download, no account, no instrumentation. 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)

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.