Features

Every run, on the record.

Fulltrace runs agent work as deterministic task graphs 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 plainly what is not here... yet.

01 · Determinism

Model proposes. Code decides.

Every workflow is a deterministic task graph. The model's job is the content of a node; the shape of the run belongs to code.

Graphs, not vibes

Structure, dependencies and concurrency are declared in code and validated before anything runs. The same workflow runs the same shape every time.

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 land in an audit ledger with provenance, from the first write onwards.

02 · 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.

Honest degradation

A run recorded before per-node timing existed says it cannot be placed on a time axis. It never draws a fake one.

03 · Approval-gated apply

No apply without a person.

A finding never becomes a change on its own. A proposed fix is frozen as a hashed artefact, simulated through the project's own build with a mandatory revert, and applied only under a grant bound to that exact artefact. 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: it refuses itself the option 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.

04 · Injection fence

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.

05 · Dogfooding

It runs its own development.

Studio's Development tab parses the live steering board, tracks the ceremony that ships each slice, and seeds the next one. The roadmap page on this site is hand-carried from that same board.

See the roadmap

Also in the box

The rest of Studio.

Seven tabs, one surface

Studio, Config, Analytics, Context, Memory, Logs and Development: operate, configure and observe from one dashboard.

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.

Cross-provider analytics

Usage and spend across your model subscriptions and API providers, side by side, with per-model token breakdowns.

Local models

A local model fleet surface: detect installed models, warm or evict their residency, and search a local docs index, all at $0.

A model per stage

Planning, execution, review and correction each pick their own model, and a run is priced before it starts.

Scope

Scope, honestly.

Fulltrace, whilst packed with features, is deliberately narrow in where and how it runs. What it does, it shows; what it does not do, it says.

  • PlatformWindows 10 and 11 today.
  • Where it runsEntirely on your machine, against a localhost gateway. Nothing hosted, nothing multi-user. Yet.
  • Who runs itA single operator. You kick off a run and can walk away; the run executes itself, and nothing is applied to a codebase without your approval. Scheduled operation is 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.

See it move.

Watch the demo See the roadmap