> ## Documentation Index
> Fetch the complete documentation index at: https://docs.pavoai.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Agent Studio
> Where Pavo turns system knowledge into applied-science work: a fleet of agents that investigates a real question and proves an answer you can act on.
[System Knowledge](/system-knowledge/overview) builds Pavo's understanding of your system. **Agent Studio** is where that understanding gets spent. You hand Pavo a real question, *which LTV proxies are safe to ship for a re-ranking change?*, and it runs the applied-science work end to end: frames the problem, breaks it into modules, puts a fleet of agents on them, and hands back a proven answer with its evidence.
The unit of work is not a task, it's a **program**: a meaty, multi-week effort your team lives inside. Agent Studio is the room where you and Pavo's agents do that work together.
Agent Studio is one of Pavo's two modules. [System Knowledge](/system-knowledge/overview) builds the understanding; Agent Studio uses it to find and prove improvements that move your metrics. Both run inside your own single-tenant environment. See [Security](/security/overview).
## Why one agent isn't enough
Point a single agent at a multi-week research question and it drifts. It runs for hours, makes a hundred small choices you never saw, and hands back something confident and wrong. In our experience long-horizon single agents don't hold up, not in Pavo's early builds, and not in the general-purpose coding agents either.
The fix isn't a smarter agent. It's **structure**:
* **A plan you approve before any work starts**: the question, the modules, and the rules of evidence, agreed up front.
* **Scoped agents**: each one owns a small, checkable piece, not the whole problem.
* **A director on top**: one agent that delegates, watches the others, reconciles what they find, and catches problems on its own.
* **Checkpoints everywhere**: the work pauses for your judgment at every boundary that matters.
That structure is what makes long, parallel research trustworthy instead of a black box.
## One program, one studio
Each question you bring gets its own studio. If you are stress-testing LTV proxies, that program has a studio; if you are deep-diving a finished A/B test, that's a different studio. Everything the program produces, from the plan to every agent's work to every plot and result, stays in that one studio, so the work compounds instead of scattering across tabs and notebooks.
## The building blocks
Agent Studio is built from a handful of primitives. They recur on every page, so learn them once.
| Primitive | What it is |
| --------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| **Program** | The multi-week question you hand Pavo. One program, one studio. |
| **Studio plan** | Pavo's approved approach: the scientific frame, the module breakdown, and the rules of evidence, agreed before any work starts. |
| **Module** | One meaty chunk of the program, with a single governing question and one result it must hand off. |
| **Task Studio** | Where one agent does one scoped piece of a module. The LTV program runs three per module. |
| **Director** | The agent above the agents: it plans, delegates, reconciles the fleet's work, and intervenes on its own when something goes wrong. |
| **Decision** | A checkpoint that surfaces for your judgment: the boundary between what Pavo does on its own and what needs you. |
| **Result** | A typed, cited, versioned answer: bounded to its sources and explicit about what it does *not* prove. |
A **Finding**, the same primitive you met in System Knowledge, is what a result becomes when it is worth keeping. Findings are written back to the [Knowledge Hub](/system-knowledge/knowledge-hub), so the next program starts smarter. That write-back is how the two modules form a loop.
## How a program runs
Hand Pavo a real question and the decision it has to inform. Pavo reads your [system knowledge](/system-knowledge/overview) to ground its plan.
Pavo returns a scientific frame and a breakdown into modules. You edit it, comment, and approve. Nothing runs until you do.
The Director delegates each module to scoped agents in their own Task Studios, and keeps them coordinated.
Work pauses at each boundary for your judgment. You accept a result, redirect an agent, or add new work mid-run.
Proven results are written back to the Knowledge Hub, so the next program builds on this one instead of starting over.
## Explore Agent Studio
Run your first program end to end.
How a program is framed, planned, and broken into modules.
How a fleet of agents does the work without going off the rails.
The decision-safe contract that makes every answer trustworthy.