commonFrame is the workshop. Attribution is captured as the work happens, so a finished piece names every contributor, person or AI, and carries that record with it wherever it goes next.
The workflows behind it are visible graphs you can open and read. Watch one run, then run it again with the model version, the prompts, the thresholds, and the memory all pinned. Next term or next audit, the run is the same run.
It runs on hardware you control, keeps each person’s work encrypted and separate, and reaches local models or outside services as you choose, with anything that leaves your network marked as such. Closed Alpha, open source under AGPL-3.0 with exception.
Desk is the writing and reading surface. Hover any span of text to see who wrote it, person or AI, down to the character. Writing alone stays yours, and the record opens when a second contributor joins, whether that is a colleague, a passage you bring in, or an AI call you make.
Bring a passage from someone else’s open chapter into your work and its contributors come with it, re-keyed into your document in the same motion. A receipt names what became of every incoming contributor, including any the record could not resolve, so work changes hands in the open.
The licence check fires the moment a source arrives, so you learn how its terms sit with your work while there is still room to act on it. It names any conflict in the licences’ own terms and leaves the judgment with you.
Writing alone stays private. The record opens on a real event, an AI call, a passage you bring in, or your own explicit gesture. When it opens it asks whether to credit you as the author of what exists so far.
The whole record prints as plain lines anyone can write out by hand and type back in. A record is a name and a letter before it is ever a file, so the practice reaches people who have no tools at all.
Every run records moment by moment into a real event log, and the recording plays like a stage production of what AI actually did. Blocks light up as they fire and a transport strip narrates in plain language. When the run finishes, the same clock becomes a replay you can scrub, pause, and step through, block by block.
Untaken paths stay on the stage, dimmed, so you see the whole shape of the decision. The recording is an immutable snapshot captured the instant the run starts.
Watch from any screen in the room, phone included. Watching rides a read-only path, so the run itself is never disturbed. The finished sequence becomes a replay you keep.
Open any block and read what happened in five plain sections: Input, Instructions, Thinking, Actions taken, Output. The categories are written for whoever has to explain the result, and nested frameworks open the same way, level by level.
Build is the canvas where frameworks are made. You wire typed blocks into a graph that runs the same way every time, and every prompt, threshold, and route lives in a block you can open and read.
typed blocks · decision thresholds · memory levels · role bindings · run record · re-run on demand
Set it block by block. The record names who made each call, and when confidence falls short of the threshold you set, the system opens a card for a person.
Reproduce runs the same framework with the same inputs and the same memory pinned to the exact digests the original used. The comparison names precisely what moved.
Adjust a framework by branching it, and both versions stand. The original keeps working beside yours, and anyone can see what changed. Frameworks export as content-hashed files, so what you hand on is the exact one you tested.
When AI commits a judgment the output arrives in two parts, in order: the reasoning in the model’s own words, then a coded verdict drawn from a word set you declared in advance. The two travel together.
Privacy is a choice the owner controls, enforced in code. The system is fail-closed everywhere: a locked vault means writes fail, never silent plaintext. A broken guarantee means the run continues and the gap goes on the record, never a silent pass.
Per-user encryption, with the tradeoff stated plainly. Shared mode lets background work run while you are away. Isolated mode means your password is the only key that exists anywhere, the administrator included. Lose the password and the data is gone, genuinely.
Outside content reaches a sandboxed copy of the running agent first, seeded with canary credentials and honeypot tools. An attack is caught in the act, and every learned pattern hardens the local database. The fork is destroyed after the test, and the live agent sees the suspicious content only once it clears.
Erasure runs atomically across the full database, with deletion itself going on the record. Tamper-evident chains and the right to erasure are reconciled by design: keyed destructible pseudonyms let you prove what happened and then genuinely delete it.
A framework asks for a role, not a specific model. Each machine fills that role with the hardware it has, so the workflow you prepared on a workstation runs unchanged on a retired desktop.
“If it doesn’t run on a Pi5, it doesn’t ship.”
A design floor: personal hardware is the baseline the whole system is held to.
Your machines form one private network. When a framework asks for a role, the job goes to whichever machine is free, so four old desktops handle four jobs at once instead of queueing behind one. A closet of retired hardware carries real work. Pairing two machines is a matching code approved on both screens.
The engine loads a model’s identity once and swaps only the working context, so material you prepare serves a full class from a single machine and the cost per person stays flat. Capable models run on a mini-PC, an integrated GPU, or CPU alone. Closed Alpha, Apache-2.0.
Run a local model against throughput, structured output, instruction following and tool use, then read the pass and fail grid. A separate pass tests how it holds up against prompt injection. You learn what this model on this hardware is good and bad at before you rely on it.
Each step of a framework’s execution carries the precise kind of work done, person and AI named the same way: drafted, reviewed, checked. DARP is an open attribution framework, Live under CC-BY-4.0.
commonFrame is in Closed Alpha, published under AGPL-3.0 with exception, the same share-alike logic open licensing already runs on: an improvement you make flows back to the commons by license, enforceable and automatic. Branch a copy, add your own material, and the base you started from stays exactly what it was.
Once a capability is free, it stays free, enforced in code. Sixteen configuration keys are frozen by write-guards that reject any managed update, verified by hash at startup. The safety baseline is free for everyone, and your data is yours to take with you.
We are openly for-profit about one thing: we charge for architecture and implementation, designing and deploying this stack inside real organizations. The tools stay free and open. Being clear about our own incentives is part of the clear box.