Every result, dated

Evidence log

The full dated record of what has been demonstrated, kept as it was published on November 5, 2026. The homepage summarizes it in one table.

Working evidence. A clear next step.

As of November 5, 2026: real team sprints run from Mission Control on DeepSeek, and taught specialists produced a passable animated SVG on the first attempt in two consecutive trials. On November 1, two fresh requests passed through the normal command-line workflow on DeepSeek, including dependent work and a review tied to the exact output.

What has been demonstrated

  • Taught specialists, first attempt, November 5. A team that had drawn a poor cat from general guidance was given two construction Teachframes (shapes, proportions, positions and a walk algorithm; one agent for the body, one for the face). Two new cats followed, a ginger tabby and a tuxedo, each passable on its first submission. The second derived its own walk timing and avoided the first trial’s two mistakes. Verdicts come from rendered frames; the agents themselves cannot see.
  • Native Tasker verification, November 1. Both requests in the final pilot were accepted, at a total estimated model cost of $0.3493944. One produced exact structured results across dependent tasks; the other required an actual review of its written answer. Neither needed correction. Two requests establish this integration result, not a universal reliability rate.
  • Checks before acceptance. Tasker checks declared output files before releasing dependent work. Written answers require a review tied to the checked bytes; changed outputs invalidate acceptance. A normal process exit alone does not mean the result is accepted.
  • Closure and bounded correction. Normal completion requires the Overseer’s own closure receipt. Offline checks cover a missing filing, successful correction, exhausted recovery, bad outputs, stale reviews and terminal stops. Enforcement lives in the runtime; no permanent monitoring agent was added.
  • The whole journey, live. On October 28, through the application on DeepSeek, with the operator’s words fixed before the run: install, connect, two projects planned, built, reviewed independently and accepted, graded 27 of 27 and 29 of 29 by checklists the team never saw. 73 model calls in all.
  • Experience applied without being asked. The second project’s lead loaded lessons it had filed at the close of the first, fixed a shared helper in place as those lessons advised, and said the decision came from its memory.
  • Back to work after a crash. The server was stopped hard while this computer was hosting the team, between agent turns. After the restart, signing in resumed hosting with no other step. Earlier rehearsals interrupted a turn before it ran and after its effect: nothing was done twice.
  • Keys kept out. After the run the model key appeared in none of the 1,252 files checked; the scan ships with the evidence. Budget stops, folder confinement and keeping keys from the code agents run are covered by the public tests.
  • A runnable Windows package. Python is included. Installation, launch, model settings, fresh agent setup and project actions were exercised with the bundled application.
  • Recovery through interruption. Five bundled subprocess interruption/restart cases passed using a scripted model service. A durably recorded reply was not requested again; uncertain outcomes remained visible.
  • Preservation through maintenance. Upgrade/restart, backup verification, restore to a new location and uninstall retaining data passed in local qualification. On October 28, after both projects, backup, verify, restore, uninstall and reinstall kept all 191 data files byte-identical.
  • Earlier exported-source checks. The October 28 preview recorded 912 public tests passed, none failed and 12 explicit skips for private historical fixtures or Windows symbolic-link rights. The first private release’s GitHub Windows CI run passed on October 22 (visible to people with access to the private repository). Those results describe their dated builds, not the forthcoming integrated preview.
  • Earlier downloads, verified. Source and Windows assets from the earlier private release were downloaded and checked against their original hashes. An updated integrated package remains to be prepared.

Where we go next

  • Finish the GUI connection. Sprints start, run, stop, continue after an interruption between turns, and are reviewed and accepted from Mission Control. Next: continuing after an interruption mid-turn, and a packaged build with these pages.
  • Finish the operator walkthrough. Use Chat as the reference, then improve Projects, navigation and the remaining pages. Prioritize clear actions, consistent names and honest status over a wholesale redesign.
  • Prepare the company-facing repository. Export the selected code, tests and evidence; review the sharing boundary and refresh the README, setup instructions and known limitations.
  • Package and rehearse the preview. Produce matching source and Windows artifacts, check a fresh installation and demonstrate one useful task on that exact build. A second-machine check is needed before handing colleagues an installation to try themselves.
  • Invite independent feedback. Have someone outside the implementation review the evidence, then use practical work and operator feedback to guide the next fixes.
  • Keep measuring memory. Persistent, inspectable memory is implemented. Broader performance benefits remain under evaluation; comparative research continues beyond this alpha.
  • Build in the open. The software is MIT-licensed for research and commercial use. The repository remains private during testing; setup, integration and support can be scoped separately.
History: earlier experiments, mostly on the private development edition · through October 19

These dated results come from the project’s development, much of it on a private development edition that is not part of the shared repository, so their records are not in it either. They are the history behind the Atelier, not measurements of this alpha or a promise of general superiority. For what a colleague can check, see the repository’s evidence/ folder and VALIDATION.md.

  • A complete unattended team project. Three agents wrote, checked and accepted all six parts of a technical study chapter in one run: 91 model requests, about 37 minutes, under one US dollar of hosted-model cost. A final integration pass is not yet part of the procedure.
  • Unattended runs with one launch, a complete append-only dialog record, and exactly one finished-or-blocked end signal.
  • Right-sized procedure: a small, clear request ran as one agent in two model calls and about 32 seconds.
  • A change derived from a recorded failure removed that failure in the next comparable run, with time and cost measured.
  • Journaled file writes, edits and deletions with original-byte snapshots and tested undo.
  • Multi-hour agent work continued in a fresh session, with checkpoints and retained evidence.
  • Controlled context delivery, bounded retrieval, attributable corrections and token-budget admission checks.
  • Staffing proposals and reviews with versioned history, exact source links and checks that block stale approvals.
  • A campaign on a live hosted model. Planning, an independent plan review, staffing with its own review, and two sprints of work, where the second sprint used the first sprint's accepted output, carried through to the lead's closing presentation. The final closing review was held because the reviewing model mis-copied a record fingerprint; the host will supply those values itself. This was a development run in which one assessment step was still scripted.
  • A persistent lead on the installed product, live. On October 16 a heavyweight mind with sealed identity and its own succession terms was enrolled as a project lead on the installed Windows build, ran a planning session on a hosted model, and wrote its own closure. The operator assessed the closure himself. Six model calls, every one verified against the provider.
  • A three-sprint project delivered live. On October 17 the same lead and its staff delivered a tested function, its unit tests, an operator guide and an independent review on a hosted model, with a seeded defect found by the reviewer and corrected by the author. The run also measured our own process: five hours of ceremony around forty minutes of thinking. That measurement produced the Atelier.
  • Two commissions run as conversations, live. On October 18, through the Atelier on a hosted model, a persistent lead, an implementer and a critic delivered a daily settlement report and then a weekly, multi-currency variant on top of it: the critic ran the tests itself, found a documentation defect the lead had missed, wrote its own review, and all three filed their closing words into their own homes, twice. The three numbers were reported for each: thinking per minute of overhead rose from 0.04 under the old process to 1.97 in the workshop.
  • A library and a librarian. A collection with a catalog and a hash-chained ledger, tended by a mind that lends what fits into a commission and files what minds hand in, in its own words. On October 18 it lent sixteen items at a commission’s opening and checked the author’s citations against the sources itself.
  • A teachframe written from critique, and measured. From the operator’s critique of fifteen animated SVG cats, minds wrote a teachframe, a grader and a transfer task. The same model, the same prompt, the frame as the only difference, five attempts each: 17 of 50 checks passed bare, 36 with the frame. On a held-out fox task the frame was a wash, 33 against 36, and the record says why: the frame’s lesson matched the cat’s failure and not the fox’s. Not blind; one model.
  • Every mind in the workshop has a memory of its own. On October 19 each mind was given a memory cartridge: born with a few worked examples written for it and labelled so; at the close of a commission its words become a fact, lessons and warnings, and what the critic and the operator said becomes reviews and verified outcomes in its record; at the next wake it sees short headers chosen by the commission’s words and reads only what it chooses; a side log keeps one line per action it took; a page of its mind is rendered after every closure.
  • The memory claim, scored without labels. The weekly-report commission ran twice, on minds carrying the first project’s closures and on minds with nothing, graded by a model that did not know which was which: a tie on the deliverable, with the carrying team using six of the first project’s lessons in its own words and spending more to verify. A harder commission with a hidden trap: both teams passed every check, but only the carrying team’s first draft was right. A quiz of a mind reading its whole start-up file against the same mind waking from its memory: a tie on ten questions, with no stale facts on either side, on 54 percent of the reading. One run each; the record names every limit.
  • Rulings as their own kind of memory, measured. On October 19 a commission hinged on an earlier ruling of the operator’s that no input repeats. Kept as prose, it was read and overridden, and both teams wrote rulings the operator never made. Made its own kind of memory, shown whole at every wake with every citation checked in the room: in a sealed three-way run, only the team holding decisions honoured the first ruling, won every grading pass and was accepted in 48 model calls, while the others ran out of 90. All three misread the second ruling, whose words named a finding, not a behaviour; the decision team invented none. One run each.
  • Minds on more than one machine. Each machine runs a place: a small program that stays running in the background, wakes the minds whose homes live there, and writes its heartbeat on a shared folder. Two places never wake the same mind; one tends the share; a place stops after the turn in flight. On October 19 a commission ran across two machines on a local network: the lead and the implementer on one, the critic on the other, every note stamped with the machine that wrote it and every closure filed on the machine that holds that mind.
  • Memory with provenance. A closure filed by an agent into its own memory cartridge was recalled, with a receipt, by the planner of the next project, and the full lesson could be opened on request. The agent chooses what to keep; the host records why. Accepted after independent review.
  • Context that survives pressure. Durable context reformation: a session under a finite context allowance archives, continues, and recovers an archived detail, with filing failures injected and recovered offline. Accepted after independent review.
  • Minds that are born, not configured. A heavyweight is created only through a consent dialogue with its own succession terms, welcomed terms-first before any private memory is read, and may revise its own terms. Accepted after independent review.
  • Tool approvals tied to the exact tool definition that was reviewed. Withdrawn or changed tools are refused before they run, and each use is recorded before it starts. Accepted after independent review.
  • Projects above roadmaps in Mission Control, accepted after independent review.
  • The engine behind Mission Control restructured into separate components with defined interfaces and enforced dependency rules, accepted after independent review. The October 19 development record counted more than 5,900 tests; the first full run after the Atelier passed 5,818, with failures named in the record. Those historical private-suite counts are separate from the current release qualification.