A software factory that shows its working: a context layer for collaboration with frontier models, a task-graph engine powering autonomous workflows, and a structured development layer that turns long product roadmaps into executable slices, all fully traced.
Demo available on desktop or tablet only.
Every new AI session used to start from zero: no memory of me, my projects, or how I work. The first ten minutes were always re-explaining yesterday.
Fulltrace is the answer: a personal operating system for the agentic era, one persistent memory that follows me across every tool, every session, and every project.
The foundation is the Context Portfolio: ten plain-text files describing who I am, what I am working on, and how I like things done. Every assistant reads the same files through a local MCP server; change one once and they all pick it up. Versioned in git, synced at the end of every session.
Where it all started: completing the AI Daily Brief - AgentOS program.
Live and in daily use. My assistants share one memory, the engine runs several kinds of job, and real changes have already shipped through it: to this site, and to my other projects' code once I have approved the exact change.
Fulltrace turns a product roadmap into shipped, verified code through a governed production line. Work enters as a slice, is designed against its risk, built in isolated commits, proved by checks that must fail before they count, and validated against the gates its kickoff named. It leaves with its record: who proposed it, what gates bound it, how it was checked, and what shipped. Most AI coding setups generate code; Fulltrace manufactures trusted change, and the trace is the proof.
A dated shipped register of over 170 slices, every one run kickoff to closeout under the same protocol. The build log narrates it; the roadmap is the live board.
Every change carries provenance and verification, not just a diff: run records, an append-only apply ledger, and gates enforced in code. The machinery lives on how it works.
Agents act under explicit, hash-bound grants with hard spend and write limits, so capability scales without scaling risk. The rules live on the workflow page.
Every assistant talks to one gateway: it serves the shared memory and runs the actual work. The portfolio files are the source of truth, git backs up everything, and the map shows the whole picture.
One system, four ways in. Each way has its own page if you want the detail.
I work in a chat with Claude Code, Codex or Cursor. Each one starts out already knowing my projects, my style and my rules, because they all read the same shared memory.
I pick a job in Studio, see what it will cost before it runs, and watch it work in real time. Code checks the result, and nothing real changes without my approval.
Features are built one small slice at a time, with a written plan, named checks and a written closeout. Riskier work faces more checks. I make every call that matters.
Some jobs run on a night schedule, inside spending caps I set by hand. Nothing that runs unattended can raise its own limit.