Credit arrives with the passage
Use a passage from someone else’s open chapter. Its contributors come with it, and a receipt shows how they became part of your work.
commonFrame gives you a place to make, run, and revisit your work. Read what was written, see who contributed, follow what a process did, and use what you learn to change the next pass.
Desk brings reading and revision together. Build lets you open the process behind a result, change a step, and run it again. The record stays with the work.
You can run it on hardware you control, choose where AI runs, and keep each person’s work separate. Bring the questions that matter to your team.
Desk is where you read, write, and revise. Bring a passage into your work and its credit comes with it. When you need the detail, open the record to see who contributed to the words in front of you.
Use a passage from someone else’s open chapter. Its contributors come with it, and a receipt shows how they became part of your work.
When a source arrives, Desk checks whether its licence fits your work. It shows you a conflict early and leaves the decision with you.
Writing alone stays private. A record begins when another contributor enters the work, or when you choose to start one. You decide how to credit what you already wrote.
The record can be written as plain text, even by hand. You can use the practice without using our software.
A closer look · Desk and DARP
You can read or revise a passage without studying its record. When you need the detail, open it to see who wrote, adapted, or reviewed each part. Take what you learn into your next draft.
The class began by asking what the river used to carry. We came back a week later to see what had changed.
This passage has changed hands a few times. Open the DARP record to see where each person—or AI—contributed, then return to the writing with that context.
Maya planned and wrote the opening sentence. A local AI adapted the second. Sam reviewed the passage. The credit stays attached when the work moves on.
<D01:A01:R01>The class began by asking what the river used to carry. </A01><A02>We came back a week later to see what had changed.</D:/A:/R>
The identifiers point to the contributor record; they travel together. This example follows the technical DARP pattern shown in our AI + OER Institute slides.
A run leaves a record you can revisit. Watch the steps, open the moment a decision was made, and see what information it had. When something goes wrong, you have a place to begin asking why.
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.
Follow a run from another screen without interrupting it. When it finishes, the replay is there for the next question.
Open a step to see its input, instructions, actions, and result. You can follow a larger process one decision at a time.
Build lets you open the process behind a result. Change a step, try another route, and keep both versions. The next run gives you something to compare.
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.
Choose who can see your work, where it runs, and what leaves your network. The safeguards stay visible when you need to inspect them.
Choose whether work can continue while you are away, or whether only your password can open it.
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 is tested before it reaches the agent doing your work.
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.
Delete someone’s data while keeping an honest record of what changed.
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.
Give each machine work it can handle. A process you make in one place can travel to another without being rebuilt around a particular model.
“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.
Connect machines you own and give each job to one with room to work.
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.
One loaded model can serve a room while each person keeps their own working context.
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.
Test a model on your hardware before you ask it to carry important work.
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.
Show who made, reviewed, and prepared the work in a shared vocabulary.
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.
Use commonFrame to make an application around your own work, or work with Clear Box to design one with you. The tools are free. We charge for the judgment and engineering it takes to fit them to a real organization.
Make a framework for your course, archive, or team. Test it, change it, and pass on the version you trust.
commonFrame is published under AGPL-3.0 with exception. You can branch a copy and build on it while the original remains available. Your data is yours to take with you.
Core free capabilities are protected by write guards. We charge for architecture, implementation, and deployment inside real organizations. The software remains free and open.