Features

Every run, on the record.

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

What your agents know before they start.

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.

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.

Shared memory

What your assistants remember between sessions sits in one searchable list, with create and guarded remove. A fact lands once, for all of them.

Reads on the record

Context is traced like everything else: per-file read counts show what your agents actually draw on, and what they ignore.

02 · Determinism

Model proposes. Code decides.

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.

The shape is fixed

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.

Gates are code

Validation gates, apply authority and approval grants are deterministic checks. None of them can be steered from inside a prompt.

A ledger from first write

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.

Written down, checked first

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.

Accepted by hand, tied to its content

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.

Refused if it writes

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

The whole run, on its real clock.

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.

Span-level detail

Inside a node: a bar per stage, and nested bars per tool call. The gaps between tool bars are real model thinking time.

Concurrency, stated

Overlapping bars mean genuine parallelism, and the trace says it in numbers: 6m 30s of node time inside a 4m 56s run.

When a number is missing

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

No apply without a person.

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:

Demo
A code audit findings report, toured in seven steps. One, the report one of the run's audit nodes wrote: the file it went to, when it was generated, the conventions it ran under, the surfaces it read, and its approved status. Two, the portfolio context the run was given, each file listed with what it was used for, how much of it was sent and a hash of the exact contents, none of which changes what the audit found. Three, every finding graded before it is read, by severity, model confidence and the risk of its fix, then located to a file, line and function. Four, why it matters kept separate from the suggested change, with a jump straight to the source. Five, a structural finding refused an automatic fix and offered a plan instead. Six, a finding graded safe offered Prepare fix, which drafts a change and freezes it as a hashed artefact without applying anything. Seven, the decision row: accept, reject, defer or ask for evidence, recorded against this report only and with no effect on future audits. 1 2 3 4 5 6 7
1 · The report a node wrote What Open full report opens: one audit node's own findings, each one a card. The header names the file it wrote them to, when it generated them, the conventions it ran under, how many surfaces it read, and that review approved it.
2 · Your context, and where it stops Every context file the run was given, with what it was used for, how much of it was sent, and a hash of the exact contents. They shape how a finding is written. They never change what it found.
3 · Graded before it is read Every finding arrives pre-sorted: how serious it is, how confident the model is that it is real, and how risky its fix would be. Then exactly where, down to the file, the line and the function.
4 · Reasoning, then remedy Why it matters and Suggested change are kept apart on purpose, so the argument can be judged separately from the patch. Open source jumps straight to the line being argued about.
5 · Not every finding gets a fix button This one is structural, and a structural fix rarely fits in one self-contained edit. So the system does not offer to make it, and offers to plan the work instead. The finding still stands, it just does not come with a patch.
6 · The safe ones get a dry-run The finding below is graded risk: safe, so it earns a Prepare fix. That drafts the change and freezes it as a hashed artefact, and applies nothing: a separate simulation has to put it through the project's own build first, and an approval binds to that exact hash.
7 · My call, and it stays mine Accept, reject, defer, or ask for more evidence, with a note. The interface says what that does and does not do, in the label itself: no effect on future audits. Nothing recorded here trains anything.
  1. 1The report a node wrote. What it audited, under which conventions, and that review approved it.
  2. 2Context in, findings unmoved. The files the run was given, what each was for, and a hash of what was sent.
  3. 3Graded before it is read. Severity, model confidence, and the risk of the fix, then the file, line and function.
  4. 4Reasoning, then remedy. The argument is kept separate from the patch, with a jump to the source.
  5. 5Not every finding gets a fix button. Structural findings are refused an automatic fix and offered a plan instead.
  6. 6The safe ones get a dry-run. Prepare fix drafts a change and freezes it as a hashed artefact, applying nothing.
  7. 7My call, and it stays mine. Accept, reject, defer or ask for evidence, recorded with no effect on future audits.

05 · Fences

Audited content is data, never instruction.

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.

Content cannot steer a run

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.

A line around the machine

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.

Rules with receipts

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

Priced before it runs. Attributed after.

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.

A price before you press run

Planning, execution, review and correction each pick their own model, and the run is estimated against real past runs before anything starts.

Attributed model by model

Spend, requests and tokens, split by model and by stage, with subscription usage and API spend side by side across providers.

Local models at $0

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

It runs its own development.

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

The rest of Studio.

Two modes, one panel

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.

A decision inbox

Everything waiting on you, in six fixed sections. A section that could not be read says incomplete instead of showing a misleading zero.

Durable run history

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.

Chat, with a receipt on every reply

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.

Schedules from the screen

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.

Audits you can aim

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

Scope, honestly.

Fulltrace is narrow in where and how it runs, on purpose. What it does, it shows. What it does not do, it says.

  • PlatformWindows 10 and 11 today.
  • Where it runsEntirely on your machine, through a local gateway. Nothing is hosted and nothing is multi-user yet. Push notifications and a read-only status page reach your phone over your own private network.
  • Who runs itA single operator. You launch a run and can walk away, or arm a schedule and let it run unattended inside spend caps you set by hand. Nothing is applied to a codebase without your approval, and approving from the phone is still on the roadmap.
  • InstallationThe Studio extension is built from source, in your editor. It is not on a marketplace, and Fulltrace is not open source today.