One portfolio, every assistant
Project context lives in one place and is served live, so each assistant starts from the same picture of your work instead of its own guess.
Features
Fulltrace runs agent work as task graphs fixed in code and records everything it does. The features below are the ones you can see moving in the demo. The scope section at the end says what is not here yet.
01 · Context
Runs do not start cold. Your project context is served to every AI assistant you use over MCP, from one place, with the same memory, commands and hooks beside it as files, and every read is counted.
Project context lives in one place and is served live, so each assistant starts from the same picture of your work instead of its own guess.
What your assistants remember between sessions sits in one searchable list, with create and guarded remove. A fact lands once, for all of them.
Context is traced like everything else: per-file read counts show what your agents actually draw on, and what they ignore.
02 · Determinism
Every workflow is a task graph. The model's job is the content of a node; the shape of the run belongs to code. Since August you can also write a workflow down as a file: it picks which code-owned stages run and in what order, and can never change what a stage does.
Structure, dependencies and concurrency are declared in code and validated before anything runs. The same workflow runs the same shape every time: replayed with no model called, 89 of 101 recorded runs reproduce exactly.
Validation gates, apply authority and approval grants are deterministic checks. None of them can be steered from inside a prompt.
Proposals, verdicts, approvals and applies are written to an audit ledger, each with who did it, from where and when, from the first write onwards.
A workflow definition is a file: which stages run, in what order, and which arrows only fire on a condition such as "the report has findings". It is checked against a fixed shape before it can load, and a file that does not fit is refused with the reason.
Nothing can use a definition until you accept it, and the acceptance is bound to the exact content. Edit the file afterwards and it is disarmed until you accept it again. An accepted definition runs as an ordinary run, and its record names the version it ran.
A definition that contains a write is refused outright, because the final whole-state check the design asks for is not built yet. Before you accept one, the tool lists where its bytes could leave the machine.
03 · Observability
Every node, stage and tool call lands as a span. The run-trace waterfall shows the run as it actually happened, including what ran concurrently.
Inside a node: a bar per stage, and nested bars per tool call. The gaps between tool bars are real model thinking time.
Overlapping bars mean genuine parallelism, and the trace says it in numbers: 6m 30s of node time inside a 4m 56s run.
A run recorded before per-node timing existed says it cannot be placed on a time axis. It never draws a fake one. Since September every panel that shows a reading says where it came from and how old it is, and an empty list gives a count and a reason.
04 · Approval-gated apply
A finding never becomes a change on its own. A proposed fix is frozen with a fingerprint of its exact contents, put through the project's own build in a dry run that is always reverted, and applied only under an approval tied to that fingerprint. This is the findings report where those decisions are made, toured:
05 · Fences
Anything the pipeline reads while auditing (code, pages, reports) crosses a fence as data. Content cannot steer the run, upgrade its own severity, or grant itself authority, no matter what it says. Two more lines are drawn the same way: around the machine, and around the rules themselves.
Every place a model reads audited content is registered, and a source scan fails if one is missing. Content can be quoted in a finding. It cannot change a severity, skip a stage or grant itself anything.
Every way bytes can leave the machine is listed in code and locked by tests, so an unlisted outbound path fails the suite. The push tool refuses a remote that is not yours, and the assistants' shells refuse the commands that send bytes off the machine.
Each of the nineteen standing rules has a record in code saying how it is enforced: a guard that refuses, a test that goes red, a checklist step, or nothing yet. A screen in Studio lists them, and a project can bend a rule only through an exemption that is off by default.
06 · Spend
Cost is part of the trace. Every run is estimated up front, every model call is priced and recorded when it lands, and a spend page shows what the runs cost by model, with any two runs of a workflow side by side.
Planning, execution, review and correction each pick their own model, and the run is estimated against real past runs before anything starts.
Spend, requests and tokens, split by model and by stage, with subscription usage and API spend side by side across providers.
Installed local models are detected, kept warm or evicted on demand, and a local docs index answers reference lookups without a paid call. Since 30 August the chat tab can use a local model too, showing memory and time instead of a price.
07 · Dogfooding
Studio's Build mode reads the live steering board, tracks the ceremony that ships each slice, and drafts the next one. The method has its own page, and the roadmap on this site is hand-carried from that same board.
Also in the box
Operate, for using Fulltrace: Work, Chat, Schedule, Context, Memory, Analytics, Logs and Config. Build, for building it: Slices, Register, Build log, UI/UX, Inbox and Gates. The panel reopens where you left it.
Everything waiting on you, in six fixed sections. A section that could not be read says incomplete instead of showing a misleading zero.
Every run lands in a local ledger with its spans, costs and verdicts, and stays inspectable after the fact. Signals mines that history into per-workflow verdict rates, a week in counts, and findings tracked run over run: new, still open, gone.
Pick a model, type, get a reply, without leaving the editor. Every reply says which model answered and what it cost, and a spending cap stops the tab when it is reached. Chat uses a key of its own: the key that runs audits cannot be read for it.
The Schedule tab shows every unattended job and whether it is armed. Arm, disarm, create and edit from the screen. The runtime checks every entry before it is written, and editing a job disarms it until you arm it again.
A scope block on the workflow sets how deep a code audit reads and how far back changes count. Each project says when it was last audited, or that it never has been, and a run that covers four of nine projects says so before the launch and in the record.
Scope
Fulltrace is narrow in where and how it runs, on purpose. What it does, it shows. What it does not do, it says.