Loomflow Studio
Studio records what your agents do so you can look at it afterwards:
every model call with the messages sent and the reply, every tool call
with its arguments, result and permission decision, every guardrail
hit, sub-agent and workflow step, with tokens, cost and time. You turn
it on once; nothing about your agents changes, and nothing leaves your
machine. Runs go into one SQLite file, and loom studio opens a web
page over it.
Quickstart
Turn recording on, either in code:
import loomflow.studio
loomflow.studio.enable()or with an environment variable, which needs no code change at all:
export LOOMFLOW_STUDIO=1Run your app as usual. Every Agent and Workflow run in the
process is recorded to .loomflow/studio.db in the current folder.
Then browse it:
pip install 'loomflow[studio]'
loom studio # http://127.0.0.1:7600Run loom studio from the same folder, or pass --db with the file’s
path. Recording itself needs nothing beyond the standard library; the
studio extra only adds the web server.
Get started walks through it step by step: where to turn it on in a script, a web app or a notebook, naming agents, opening the page, and what to do with it day to day.
What you see
- Traces. One row per run: status, agent and version, input, user,
model, tokens, cost, time and score. Filter by agent, user, model or
status, show only errors and interrupted runs, or search everything
recorded (prompts, replies, tool arguments and results). Click a
session_idto see a whole conversation. - A trace. The run as a timeline: the agent run, its turns, model calls, tool calls, guardrail hits, and any sub-agent or workflow steps, nested the way they ran. Click a step to see what it did: the messages a model call sent and its reply, a tool call’s arguments, result and whether it was approved, a guardrail’s verdict.
- Agents. Every agent and workflow that has run, with its versions. Studio records a new version whenever the instructions, model, tools, team or settings change, and notes what changed, so a regression points at the change that caused it.
- Architecture. Each version drawn as a diagram: the sub-agents in a team and how they delegate or hand off, a workflow’s steps, routes and parallel branches, and the tools each agent holds. On a trace, the same diagram highlights the agents, steps and tools that run used, so you see which path a request took.
- Experiments. Each
EvalHarnessrun, grouped by dataset. Compare two runs case by case: which cases improved, which regressed, and how cost and latency moved. - Scores and datasets. Mark a run good or bad on its page, and add
a bad one to a dataset with the answer it should have given. Then
run your evals on that dataset with
loomflow.studio.dataset("name").
Try it on a demo
examples/34_studio.py
records a small support bot with scripted models, so it runs offline
with no API key: two versions of a billing agent, a tech-support
agent, a routing workflow, a supervisor team, an error, a run that
hits its turn limit, and two eval runs to compare.
python examples/34_studio.py
loom studio --db .loomflow/studio-demo.dbStudio is a local tool: one file, no account, no server to run besides the page itself. It records loomflow runs. For monitoring production across a fleet, also export OpenTelemetry to your tracing backend; the two work side by side.
Next
- Get started: set it up step by step and use it day to day.
- Example: evaluate a RAG agent: a whole loop, from a working agent to scores you can compare.
- What gets recorded: the switches, what a trace holds, agent versions, privacy, sampling and storage.
- Scores and experiments: scoring runs and comparing eval runs.
- The web app:
loom studio, its pages and URLs, and keeping it private.