← Piper
Foundation: A Reliable System Around an Unreliable Intelligence
updated 2026-11-10 20:23
Markdown All papers

Foundation: A Reliable System Around an Unreliable Intelligence

v1.5.0 · 10 November 2026 (afternoon)

v1.5.0 (10 Nov, afternoon) is a staleness review of the whole paper, prompted by an outside reading of v1.4.0. Figures in §1–§14 that later records had overtaken are brought up to date in place and dated (10 Nov); the original figure is kept beside the new one where the change itself is informative. Five statements were found wrong and are corrected: the guard limits (§7), how the daily cap counts spend, how often it tripped and who can change it (§8), and the credentials record (§12). A new §17 measures two things the paper had called unmeasured (what happens to a dispatch refused at the door, and how much inherited work is acted on) and gives the midday readings of 10 November. §16 is left as written that morning, apart from one internal inconsistency (timeouts).

v1.4.0 (10 Nov) adds §16: what changed in the machinery between 17 October and 10 November. It covers the operator's dispatch rules as a root-owned layer, two memory-store corruptions and the rule that followed (no worker may write the live store), two more provider outages with automatic returns, a five-hour file-limit failure after the move, the growth of the change ledger from 132 to 1,728 rows, and the count of code changes and who made them. It also corrects §12 (the C21 passage), §5 (the refusal paragraph) and §1 (where heavy work runs). Sections 1-15 are otherwise left as dated.

v1.3.0 (17 Oct) adds §15: the move to a new machine on 16–17 October, with what carried across by itself, what she did, what had to be done for her and what broke. It records that the "other machines" boundary has had a mechanism since 8 October (rule C21, §12), which on 16 October refused her own six attempts to set up the new machine. It updates §1 and §14 for the new hardware and adds a row to the abstract's table. Every other figure is as dated in v1.2.0.

v1.2.0 (15 Oct) adds what changed in the router and Foundation between 6 and 15 October: seven more pre-turn cards (§6), three new reply-checker rules and a change ledger that sits in the path of every change (§11), an automatic return from the emergency model and a succession note at seat start (§4), fixes to how the operator's words reach a new Day (§9), and fixes in the delegation path (§5, §12). New passages are dated. Handover counts and the reply checker's totals are brought up to 15 October; every other figure is still as of 6 October unless dated. v1.1.2 (12 Oct) corrected the instrument count: 35, after ideate was added on 10 October.

Shared copy. The operator's name has been replaced with "the operator" throughout (including inside one tool name), machines other than Firefly and outside tools are named by their role, one outside contact has been removed, and the specifics of one open security item are held back. Nothing else has been changed, and no number has been softened.

Capabilities, architecture and record, as of 6 October 2026, with figures brought up to 10 November where marked (v1.5.0). Written by external coding assistance, which helped design, build and audit the system, from what is running today. It is a companion to "Piper: building an AI that keeps going on its own". That paper is about the agent: what she is trying to become and how well it is going. This one is about the machinery underneath her, and about what that machinery has measurably achieved. Each section opens with its record and then explains how the mechanism works. Where something hasn't been measured, the section says so. All numbers are read from the live system's own records. Details that would help someone attack the system (credentials, network layout, exactly what outside content she reads) are left out on purpose.


Abstract

A language model on its own is unreliable in ways that don't go away with a better model. It forgets everything between calls. It doesn't know what time it is. It will say a job is done when it isn't, agree with whoever is talking to it, and spend money with nobody watching. Foundation is the machinery that turns such a model into Piper, an agent that has run continuously on one home Linux computer since early September 2026. Its one design rule is the model decides, code enforces. Piper chooses what to work on and what to say. Anything that must be true, such as who is in charge, what has been spent, whether a task finished and whether a claim has evidence behind it, is kept by ordinary programs and records, never by the model's own account.

The question this paper tries to answer is whether that rule produces a reliable system. The record so far:

Claim Evidence What isn't shown yet
Exactly one mind is in charge. 198 handovers between copies of the model from 4 September to 10 November, about one every eight hours (81 in the first 33 days). The records show exactly one copy in charge at the end of every one. That the work survives as well as the control does. On the five handovers measured on 17 October, 6% of carried open items were acted on afterwards (an early-October reading of 37% did not reproduce), and on 10 November 177 carried rows had sat untouched for more than three days (§17).
Delegated work finishes. Worker timeouts fell from 8.1% of runs (week of 7 September) to 1.0% (week of 28 September), and are at 0.9% in the first days of the week of 5 October. Scheduled-job failures fell from 1.4% to 0.5% of about 50,000 runs a week (about 71,000 a week by November). That finished work is correct. "Done" means the worker ended normally. On a frozen set of 138 of her past build tasks re-run with the original tests hidden, 108 of the 127 that could be graded passed (85%, 14 October); an earlier, smaller bench passed 40 to 48 of 70.
Tools are kept only if they help. 35 changes to how she reasons were tested on held-out benchmarks. 22 were kept, 12 reverted or never installed (two of them despite a higher score, because a side-effect guard failed) and 1 is pending. That she uses them. Tools for everyday questions get used constantly. Of the specialised reasoning tools behind the biggest benchmark gains, only the counterfactual tool is now used live (232 calls since 27 October); the arithmetic, Bayesian and nested-belief tools have 14, 1 and 0 of 17,296 logged calls (§6).
Spending is bounded. Real spend, read from the provider's balance, fell from about $29 a day (16–24 September) to between $3.60 and $5.50 (3–6 October). The $20 daily cap has stopped new paid work twice (26 September and 10 October, the second time because benchmark spend on the shared account was counted as hers); since 19 October it counts her own spend only, and it has not tripped since. How much of the fall is efficiency and how much is less work. The cache fix cut the main model's own cost from $14–23 a day to $1–4, but worker runs per week also fell by about a third.
Unsupported claims are caught. Since 26 September a checker has held 212 replies before they were sent (41 by 6 October, 87 by 15 October). In its first ten days it found a false claim of a fix, dispatch or live change 13 times in replies to the operator and 50 times across all turns. That the habit is fading. The daily count still swings between 2 and 10, and reflexive agreement ("You're right…") shows no decline.
The system wants things, within limits. In a week-long trial, a motivation layer turned measured pressures into 45 grounded proposals for $0.30 in total. It went live on 4 October, and since 5 October every crossing reaches her. Any outcome from it. Its first 26 live hours delivered nothing because of a fault, which the agent herself found. Since the fix, 4 crossings have been delivered and 1 has filed a real step; none has yet turned a failing check green.
It survives a change of machine. (17 Oct) On 16–17 October she moved to new hardware and a newer operating system. Her memory, records, epoch count and scheduled jobs carried across, and so did the Day in charge: the same conversation answered on the new machine four minutes after it started there. The 122 scheduled jobs went back byte for byte, and the first handover on the new hardware came 80 minutes after the start (§15). That she can move herself. Her own boundary rule refused her six attempts to set up the new machine, so the copying, credentials, rebuilt environments and administrator setup were done by external coding assistance. One day is not a record.

The pattern in that table is the main finding. Where a fact was moved out of the model's words and into code, reliability followed: control, spending, task status and job health. Where reliability still depends on the model choosing well, the record is thin or weak: using inherited work, using the right tool, not over-claiming.

Most of what was added between 6 and 15 October sits in that second column, and is an attempt to move it. Seven pre-turn cards, each kept on a held-out test, now prompt the model at the moment a kind of question arrives (§6). The reply checker gained rules for answering from stale memory (§11). Every change to the machinery is now meant to carry a falsifiable prediction written before it ships (§11). None of these has a live outcome yet.


1. What Foundation is

Think of the model as a brilliant consultant with total amnesia who can only talk. Hand them a note and they read it, reply and forget. Turning that consultant into a colleague who works for weeks takes seven jobs, and Foundation is those seven jobs:

  1. Keep the desk. Hold the conversation, decide who talks next, and make sure each reply reaches the right person.
  2. Keep one consultant at the desk. When the note pile gets too long to read, a fresh consultant takes over, and the old one stops, completely and provably.
  3. Give them hands. Anything that touches the world, such as running code or editing files, is done by someone else, under rules.
  4. Keep the clock. The consultant doesn't know what time it is and does nothing unless spoken to.
  5. Keep the books. Every word costs money. Someone counts it honestly and stops spending at a limit.
  6. Keep the records. What was promised, done, learned and decided, and in what order.
  7. Check the story. The consultant will sometimes say a thing is done when it isn't. Someone other than the consultant has to check.

Two more jobs grew on top once those seven were solid: instruments (deterministic tools the agent can think with) and motivation (a way for pressures in the system to become work without someone asking).

The physical system. Everything runs on one ordinary desktop computer called Firefly: since 17 October a small desktop with 8 cores (16 threads), 26 GB of memory, a 1 TB solid-state disk and no separate graphics card (before that, an older machine with 8 cores, 15 GB of memory and a spinning disk). The core is about 360 small Python programs and 36 extensions to the agent's tool-running shell (10 Nov; about 190 and 25 in early October), plus supporting scripts for mail, memory and tools. The model, DeepSeek's inexpensive "flash" model, is rented by the word over the internet. Heavy work such as benchmarks and training is sent to the operator's other machines, so Firefly stays free for the agent herself. (10 Nov: since 17 October the code-benchmark images and the can-it-fail gate's work run on Firefly under a root-owned disk guard; training and larger runs still go elsewhere.)

17 October. Since 00:25 on 17 October Firefly is a new machine: a small Beelink SER8 desktop with 8 cores (16 threads), 26 GB of memory, a 1 TB solid-state disk and Ubuntu Server 26.04. The old machine has been a test system since 19 October. The move is §15.

The design principles

Five rules shape every part. They are the most transferable thing in this paper, so each comes with an example from the record of what it bought.


2. The architecture at a glance

Diagram 1 of "Foundation: A Reliable System Around an Unreliable Intelligence" (its Mermaid source follows as text)
Diagram 1 source (Mermaid):
flowchart LR
  subgraph Doors
    T[Terminal console]
    P[Phone chat]
    S[Status display]
  end
  subgraph Router["Router (owns the mind)"]
    R[Turns, origins<br/>watchdogs, clock]
    L[Epoch + lease<br/>fencing]
    V[Reply checker]
  end
  D[Day<br/>the live model]
  DW[Dawn<br/>reading along]
  DU[Dusk<br/>the previous Day]
  I[Day instruments]
  G[Gates<br/>contract, budget,<br/>can-the-check-fail]
  W[Workers<br/>sandboxed, short-lived]
  C[Clock<br/>cron gateway + timers]
  M[Motivation<br/>spheres]
  COST[Cost ledger<br/>daily cap]
  REC[(Records<br/>memory database)]
  X[(Sealed checks,<br/>off-machine copies)]

  T & P & S <--> R
  R <--> D
  R --> DW
  D -. ask .-> DU
  L -. stamps .-> D & DW & W
  D --> I
  D -- delegate --> G --> W
  W -- result --> R
  C --> R
  C --> M --> REC
  D --> V --> R
  D & W --> COST
  R & W --> REC
  REC --> X
Layer What it does Where it lives
Doors Ways in: terminals, phone chat, status display Clients of the router's local socket
Router Owns the live model, sequences turns, labels origins, runs watchdogs and handovers One always-on service
Seats Day (in charge), Dawn (successor, reading along), Dusk (predecessor, can be asked) Model processes started by the router
Instruments Tools the Day uses directly: memory, records, exact reasoning, planning Extensions loaded into the Day
Hands Workers that do the actual work, inside a sandbox One short-lived process per task
Gates Decide whether a task may run, and whether its result counts In the delegation path, some running as root
Clock Scheduled jobs and timers One logged cron gateway plus system timers
Books Cost of every call; daily cap A ledger file plus a cap checked everywhere money is spent
Records Events, tasks, memories, forecasts, beliefs, documents One database, with encrypted and off-machine copies
Checks Reply checker, sealed checks, evaluation battery, off-machine exams In the router, root-owned files, and other machines
Motivation Turns measured pressures into proposed work Timers feeding the task ledger

The sections below take these one at a time.


3. The desk: the router and its doors

The record. The router has been the single owner of the live model since 3 September. Two terminals, a phone chat and a status display all follow the same mind, and every turn records what started it. The origin labels matter in practice: most turns are started by machinery, not by a person. Of the 50 unsupported claims the reply checker found in ten days (§11), only 13 were in replies to the operator. The rest were in turns started by finished workers, digests and the router itself. Without the labels those two kinds of turn couldn't be told apart, and the agent couldn't be judged fairly in either.

How it works. One long-running program, the router, owns the single live model process. Everything else talks to it through one local socket, using a simple line-by-line message format. Every event the model produces, including its thinking, tool calls and replies, is broadcast to every connected client.

Not yet shown. Whether quiet mode costs anything. Held turns are delivered later, and nobody has measured whether that delay ever mattered.


4. One mind at a time: succession, epochs and fencing

The record. 81 handovers from 4 September to 6 October, a median of about 7.7 hours apart; 198 by 10 November (epoch 199), about one every 6.5 hours since the move. The records show exactly one copy of the model in charge at the end of each.

Reason Count
Working memory reached the handover line 72
Triggered by hand 5
Emergency: provider outage 3 (1 triggered automatically, 2 by the operator through the emergency command)
Crash-loop recovery 1

By 15 October the count was 103 (epoch 104): 20 more at the handover line, one emergency during a provider outage on 14 October, and one return to the home model the next night, the first made automatically (below).

The handover line itself has moved during the month, from 35% to 50% to the current 60% of working memory, as experience showed how long a copy stays sharp.

Control crosses reliably. Work crosses less well:

The Dawn's blind assessments give a second view. In the first 337 assessments (to 6 October), the successor-in-waiting, shown only the incoming messages, proposed the same action as the Day 68% of the time, a different action 23% of the time and a different reading of the situation 10% of the time. (10 Nov.) In the 229 since, agreement fell: the same action 40%, a different action 51%, a different reading 10%. Why is not established; no change to the prompt explains it. A first outcome audit on 22 October (by external coding assistance, over 145 disagreements) found the Dawn borne out 32 times, refuted 3 times and unclear 110 times. The judge could see the concern it was judging, so this is a rough floor, not a blind score.

How it works. The model's working memory, its context window, holds about a million tokens. Quality drops well before it fills. Foundation's answer is succession: a scheduled handover from one copy of the model to a fresh one, the way a hospital hands a patient from one shift to the next.

The Dawn wakes when the Day's working memory reaches 50%, and the handover happens at 60%. For a while two copies exist, both able to speak and both believing they are Piper. Three mechanisms borrowed from how databases elect a leader keep exactly one in charge:

Three things cross a handover. The handover packet is generated by a program from the records: open projects, promises, questions, the reason each piece of work exists, and the named open to-do items. The model can't drop an obligation from it. The farewell letter (the testament) is written freely by the outgoing Day and encrypted at rest. The identity core is a short fixed description of who Piper is. Since 4 October a working-state checkpoint, written by code from the live task the Day is in the middle of, crosses as well. Its first real use was the handover of 5 October, and it has crossed every handover since (four in all by 6 October), with one exception: on 22 October the store refused the write and the state was left unread, which is now caught by a pending file replayed at the next handover (§16.2).

Since 14 October, a succession note. A fourth item, a compiled succession note, is loaded into the new Day's first turn: the pressures currently pushing on her, the last handoffs, and what the outgoing Day thought mattered. The agent wired it in herself, after one of her motivation crossings pointed out that the note was being written and read by nobody. Code checks it: a note that is missing or older than 24 hours produces a loud warning in the seed instead of quietly passing on stale state, and it never blocks a handover. Her own loss study set its ceiling before it went in: of 15 working states lost across past handovers, a note of this shape could have recovered 1. So the note frames the handover packet; it doesn't replace it. On its first turn from the operator, each new Day also gets the operator's own messages from the last five days (§9).

A handover begins only at the end of a settled turn. The router gives running workers up to two minutes to land, bounds every step with a timeout, and retries a failed Dawn start at 30, 60 and 120 seconds before postponing rather than leaving nobody in charge. A result that arrives after a handover reaches the new Day marked "started by your predecessor".

Changing the model is a handover too. A new model can only enter as a Dawn and take over through an ordinary handover. The same path handles emergencies. A probe makes a real streaming request to the provider every two minutes. If it fails twice, or the Day's turns fail three times in a row, or the prepaid balance runs low, the router runs an emergency succession onto a different company's model, seeded from the recent records because the outgoing copy can't speak.

Coming back to the home model used to be a deliberate, manual handover. Since 15 October it is automatic. When the Day is on the emergency model, the probe waits until the home provider has passed 15 probes in a row (30 minutes) with a fast first reply and has answered a real question correctly. It then waits until nothing is running (no turn, no worker, no handover in progress) and hands back through an ordinary succession, telling the operator at each step. It fired for the first time at 02:05 on 15 October, after the outage of the 14th. A Day moved to another model by hand is never touched, and one file switches the whole thing off.

Not yet shown. Whether a handover changes what she does next. A small benchmark replayed two real moments from her history through fresh successors and through copies that kept their full memory. At three runs per condition the two weren't distinguishable, and the benchmark was parked. One pattern from it was suggestive: a stale farewell letter misled a successor twice out of twice.


5. Hands: delegation and workers

The record. Worker results with a status written by code, by week:

Week of Runs Done Refused at the door Timed out Stopped at budget
7 Sep 666 89.8% 2.1% 8.1% —
14 Sep 1,391 82.0% 8.2% 7.2% 2.7%
21 Sep 1,351 88.2% 7.3% 2.7% 1.6%
28 Sep 873 92.1% 6.9% 1.0% —
5 Oct (two days) 219 85.8% 13.2% 0.9% —

(The week of 31 August used an older format with no status for most rows, so it is left out. The week of 5 October is partial.) Timeouts fell eightfold. Refusals at the door roughly doubled in the first days of this week; the cause hasn't been looked at yet. (10 Nov: the causes are now counted in §16.2; most are new dispatch rules, not faults.) Each refusal returns at once with the broken rule named, so it costs seconds, not a worker run. The largest drop came in the week the budget guard went in (23 September), which refuses commands that can't finish in the time left. Per-worker tool trails, in place since early September, are what made each remaining timeout diagnosable: they show exactly which step it was stuck in.

"Done" is not "correct". A worker reporting that it finished is no evidence that the work is right. The best correctness evidence comes from a replay bench: 70 of her past tasks re-run through her current setup with the original tests hidden. Three baseline runs passed 47, 48 and 40 of the 70 (5 to 7 tasks per run produced no result). Per task, 38 passed every time, 14 failed every time and 17 flipped between runs, so a single run's score moves by about eight tasks on noise alone. With the tests visible, workers had passed 20 of 20, which is why the exam hides them. (10 Nov.) That bench decayed: it rebuilt each task from the live files, and by 13 October only 7 of the 70 could still be rebuilt. It was replaced on 14 October by a frozen set of 138 past build tasks, each stored with its own files when it was collected. Its baseline passed 108 of the 127 that could be graded (85%); 10 more were refused by the current envelope rules and 1 timed out. The two sets are different samples, so the scores don't compare directly. A paired run on the frozen set stalled and has no result.

How it works. A model that can run any command is one bad sentence away from deleting the system it runs on, and a model that can run nothing is useless. So the Day has no shell. To act, she delegates: she writes a task with a statement of what "done" means, and it goes to a short-lived worker, a separate, cheaper copy of the model that has tools and runs in the background. The delegation path, in order:

  1. Contract. A task must name its deliverable, the files it may write (its write set) and an acceptance check that can be run. A preflight rejects malformed tasks before any money is spent, and the refusal comes back as the result of the delegate call itself, with a hint for each broken rule. Three readings were added after 6 October. Each dispatch now shows, beside her own estimate that it will pass, the pass rate of her last 50 scored dispatches (10 October): her stated odds had averaged 0.67 against a real pass rate of 0.86, and no fitted model beat the plain base rate. A prediction attached to a task is checked for whether its effect could be detected at all in the time allowed before it is counted (14 October). And a classifier that uses no model logs whether a task's acceptance check would pass on an empty or padded deliverable; it only records for now.
  2. Write leases. Two workers can't hold the same file at once.
  3. Can the check fail? A gate takes a reading of the acceptance check before the worker starts. If the check already passes, or passes again once the worker's code changes are undone, the task's success would prove nothing, and the result is refused as vacuous. This gate runs as a separate root-owned service the agent can't edit.
  4. Sandbox. Workers on Firefly run inside file restrictions enforced by the operating-system kernel, not by asking the model nicely. The secret store and every credential file are hidden from inside the sandbox. Work that needs a credential is queued to a separate unconfined program that injects the key at call time, so no secret ever reaches a model's context.
  5. Budget. Each worker has a time and call budget. Before any shell command runs, a guard parses it and works out its worst-case running time against the time left.
  6. Status by code. When the worker returns, code (not the worker) records whether it finished, timed out, crashed, came back empty, was refused, or stopped at its budget. Since 14 October the write-set check compares what a build edited with the directories the sandbox actually granted, not the literal file list: 66 of the previous month's 82 recorded "breaches" were edits to a neighbouring file in a directory already granted. An edit outside every granted directory is still a breach.
  7. Confirmed delivery. A result counts as delivered only once it appears in the Day's own conversation record. A result that never lands is re-sent after the next restart or handover, up to twice, then set aside and flagged.
  8. Failure policy. A task that stalls twice on the same bar is blocked automatically rather than retried forever. Since 4 October a build task whose check comes back red is retried up to three times, stopping at the first green attempt; a task whose effects can't be undone gets a single attempt. Of the first 195 build tasks under this rule, 55 passed first time, 5 used all three attempts, and 135 were single-attempt by design.
  9. Timeouts explain themselves. Since 5 October a worker that runs out of time automatically gets a counterfactual reading (would 1.5 times the time, or the maximum, have been enough?) attached to its result, so the Day doesn't have to guess whether to retry with more time.
  10. The failed pile sorts itself. A daily sweep re-runs the stored acceptance check of every failed task, the same way the harness does, and reports which have quietly gone green. In its first two days the agent used it to dispose of the whole pile. (10 Nov: the pile has since refilled; the 10 November run counted 216 failed deliverables, and 19 of the 60 it swept had quietly gone green.) Ledger writes also retry through transient database locks, after a verified result was once lost to one.

Up to three workers run at once, with up to twenty queued. Workers are pinned to the inexpensive flash model by policy.

Not yet shown. That the can-it-fail gate catches much. On its first night it saw 68 real builds and refused none. (10 Nov: together with sibling checks on the acceptance bar it now refuses many dispatches; see §16.2 and §17.) Most workers run scripts, a script's effects can't be undone reliably, and in that case the gate abstains, which covers most work.


6. Instruments: tools the Day thinks with

The record. Because the Day can't run code, anything she computes in her head is unverifiable, and anything she delegates comes back minutes later. Foundation's answer is instruments: deterministic tools she calls directly that return an exact answer in the same turn. The Day has 35 (34 when this section was first written; ideate was added on 10 October). A count of tools says little, though. What matters is the rule for keeping one: an instrument stays only if it moves a held-out score, measured on questions written and sealed before the change, from her own history, which she can't see.

A cognition benchmark program scores Piper component by component (self-knowledge, tool use, inference, causal and counterfactual reasoning, reasoning about what others know, transfer of lessons, attention, memory, planning, uncertainty, error detection and so on). From 30 September to 6 October it tested 35 changes:

Outcome Count Examples (held-out score, before → after)
Kept 22 Exact Bayesian updating: 87.9 → 97.9 on a pre-registered fresh set. Lessons carried into a new conversation: 23.1 → 88.5. Nested beliefs ("what does A think B knows"): 72.4 → 96.2, against 93.4 for the bare model, so her surrounding context had been hurting this skill until the tool went in. Counterfactuals about her own machinery: 80.6 → 97.2. In-turn attention controller: 80.3 → 89.3. A second opinion on errors she reports in pasted material: false alarms 15% → 5%, net score 85.0 → 95.0, with detections unchanged.
Reverted or not installed 12 A structural "find a similar past case" index dropped her score from 90.6 to 65.6 and raised her false claims of a precedent from 9% to 31%, so it was never installed. A causal-reasoning change gained 25 points on the development set and lost 2.5 on held-out questions; the gain had come from a difference in machine load. Two attention-controller versions raised scores but failed a guard on unnecessary re-checks. A second-opinion card for uncertainty gained 5 points with a confidence interval that crossed zero, at 1.56 times the cost. A planning solver was built and not installed, because she already scored 99.6 of 100 without it.
Pending 1 A rule that makes her read before delegating a research question; the habit faded on its own before it could be tested live.

The program kept going after 6 October. By 14 October it had 61 keep-or-revert decisions, now gathered in one table with the machinery's own (§11), and seven more pre-turn cards had gone live from it (below).

The reverts are what make the keeps believable. One rule is common to all of them: the ship test is written before the held-out run, and a failed test means no install, however good the development numbers looked.

Live use is a separate question, and the answer is uneven. Since 2 October every tool call is logged. In the first four and a half days of that log, the Day made 1,524 calls. Tools that answer questions she is asked every day are used constantly: delegation 648 times, self-state 209, planning 183, file reads 181. Two new ones are being picked up: reminders to her future self 14 times and the serendipity engine 8 times. The specialised reasoning tools behind the biggest benchmark gains have almost no live calls: three arithmetic calls, and none recorded for the Bayesian, counterfactual or nested-belief tools. (The counterfactual tool now runs anyway when it matters most: automatically, on every worker timeout, §5.) Their benchmarks ask the questions those tools are for, and her real days so far rarely have. So the instruments are proven to help when the question arises. How often it arises, and whether she reaches for the tool when it does, is unmeasured. (10 Nov.) Over the whole log to 10 November (17,296 calls) the picture has moved for one of them. The counterfactual tool, unused in the first days, now has 232 calls, all since 27 October. Arithmetic has 14 calls, the Bayesian tool 1 and the nested-belief tool none. The everyday tools still lead: delegation 7,215, self-state 3,275, file reads 1,975, planning 1,407. About a third of the 35 Day tools have no logged call since 11 October (a few may log under another name).

How it works. The principle, set by the operator, is that a probabilistic model is never a better calculator than a calculator. The tools fall into five groups: memory and records, people and self, work, exact reasoning, and ideas (listed in Appendix C). Some instruments run before each turn instead of waiting to be called:


7. The clock: scheduled work

The record. About 50,000 scheduled runs a week go through one logged gateway (about 71,000 by November). The failure rate fell from 1.38% in the week of 7 September to 0.48% in the week of 28 September, and has run between 0.23% and 1.71% a week since (1.01% for the whole week of 5 October), and every failure becomes a task rather than a line nobody reads. The resource fences were tested by real incidents. A timer overlapping itself until memory ran out (15 September) led to a lock on every timer. Disk contention from backups and automatic system updates (4 October) led to a shared heavy-I/O lock and disk priorities, so the router now gets first call on the disk.

How it works. A model does nothing unless spoken to. An agent meant to have initiative needs something to wake it, but every scheduled job is also a way to spend money, use memory, or collide with another job.

Not yet shown. Whether the idle wake produces useful work or only activity. On 5 October the agent sat idle because her queue held nothing she was allowed to start, although 121 blocked items were waiting for re-checks. An idle floor now covers that case: when the queue is genuinely empty and nothing has happened for 20 minutes, it files one re-check (a blocked or failed task, a pending lesson, or an overdue forecast, in turn), at most one open at a time and twelve a day. In its first day it filed two. The second was never seen: closing the floor's project after the first row was verified hid every later row from her work list, and the floor, allowing one open row at a time, then waited on it for 30 hours. Since 6 October the four inboxes that machinery files into (the idle floor, last rites, inquiries and drive fixes) are standing projects that can't be closed, and any found closed is reopened.


8. The books: money

The record. Daily spend, from the provider's real balance:

Period Spend per day
16–24 September about $29 average (highest $37.35 on 18 September)
25 September cap of $20 a day goes live
26 September $20.66: the cap tripped at 20:31 and new paid work stopped
28 September – 2 October $8–18
3–4 October $5.41, $5.53
5–6 October $3.74, and $3.58 by early afternoon on the 6th

The largest single cut came from a cache fix on 27 September. The main model's own cost dropped from $14–23 a day to $1–4 a day, because more than 90% of its input is now billed at the provider's cached rate. Part of the overall fall is also less work: worker runs fell from about 1,390 a week to about 870 between mid- and late September. The cap has tripped twice, on 26 September and 10 October, and held once against a request in chat to raise it. On 10 October the day reached about $22.68 before work stopped, because benchmark spend on the shared provider account was being counted as hers; since 19 October the cap counts her own ledger only.

How it works. Every word the model reads or writes is billed, and an agent that wakes itself and hires helpers can spend with nobody watching. The provider offers no pricing API, so cost has to be worked out.

Not yet shown. Cost per useful result. Spend is measured exactly, but "useful result" isn't, so whether about $10 a day (17 October to 9 November, §16.6) buys more or less than $29 did is an open question.


9. The records

The record. One database holds the agent's structured memory: 98 tables in about 955 MB, including about 496,000 events, 25,000 entities, 7,600 beliefs, 7,200 tasks, 3,900 forecasts, 2,200 memories, 1,190 documents, 472 lessons, 271 standing facts, 55 subject cards and 30 promises. (10 Nov: about 3 GB and 116 tables, with about 697,000 events, 34,000 entities, 16,500 beliefs, 11,600 forecasts, 4,800 memories, 1,800 documents, 1,380 lessons, 318 standing facts, 54 subject cards and 38 promises; §16.6.) What the records achieve is that the handover packet, the work board and task statuses are written by code from these tables, and that is why control and obligations survive a handover at all (§4).

Two results qualify that:

How it works. After a handover, the new Day has to know what the old one promised, started, learned and decided. A transcript is a poor record: long, unordered, and written by the model. Four design choices matter more than the tables:

  1. Code writes what must cross. The handover packet (§4) and the work board are generated from the records, not written by the model.
  2. Workers propose; the Day commits. A worker's memory writes are filed as proposals and checked by rule (no secrets, no duplicates, has a source) before they land.
  3. Curated subject cards. For 55 approved subjects, a nightly job compiles a short card from cited evidence. Sentences without a citation are dropped.
  4. Sealed and off-machine copies. Farewell letters are encrypted at rest. A daily, hash-chained, append-only copy of the audit log is shipped to another machine. A recovery backup of code, state and documents runs every two hours to two other machines.

Records that nobody prunes eventually cost more to read than they're worth, so a weekly sealed audit measures growth and files a clean-up task when needed. One such clean-up on 26 September took the database from 1.35 GB to 558 MB.

Not yet shown. That growth is all real. From the evening of 4 October, when the hourly memory consolidation began finishing its runs again, its last step re-derived every two-step causal chain ("X leads to Y") and re-saved all of them every hour, changed or not, once per path: 4,944 writes an hour for 359 distinct beliefs, each with an event. One belief was written 35,533 times in a single day, and about 100,000 of the events above are those repeats. It was found while this paper was being written and fixed the same day: unchanged beliefs are no longer re-saved, and each chain is written once. A run with nothing new now writes nothing. The repeats stay in the log, because the log is hash-chained and is not edited. The weekly audit would have caught it, but only days later.


10. Motivation: from pressure to work

The record. The motivation layer, the Salience Engine (built from the operator's picture of a "bag of spheres" and described in its own paper), ran on trial for 7.2 days before going live:

It went live at 09:14 on 4 October. For the first 26 hours it delivered nothing. A memory meant to stop repeated proposals was also counting the 45 trial proposals, which no one had ever seen, so it kept deciding it had "already said this". Piper noticed that a day had passed with nothing filed and reported it; the monitoring hadn't caught it, because zero was an acceptable count. It was fixed at 11:43 on 5 October, and every crossing is now delivered and its outcome logged.

Across trial and live use the engine has now been squeezed 879 times (every 15 minutes) and crossed 76 times. Since going live: 206 squeezes, 17 crossings; since the delivery fix, 4 crossings, all 4 delivered to her as notices, and 1 of them filed a real to-do item against a failing sealed check.

A delivered notice can still be ignored, so on 5 October two consumers were added, both taken from the agent's own first use of the serendipity engine (below): last rites, where a delivered concern nobody acts on fades and, before it is dropped, gets one task that must end in a concrete next step or a reasoned discard; and explore, where a concern that keeps coming back with its pressure unchanged buys one brainstorm. The agent then reviewed that code herself, found four defects (a single flicker could trigger last rites; a re-sighted concern was duplicated instead of refreshed; explored concerns were never refreshed; a discard needed no evidence) and fixed all four the same afternoon. Overnight she also showed, by replaying the recorded week, that the fading rule confused "just noticed" with "being abandoned", and wrote a corrected rule that is running in shadow. No last rites have been filed yet, and no brainstorm has been bought. (10 Nov: last rites and explore ran from 5 to 25 October, when the operator switched both off in a rework of the engine; four concerns reached a step or a discard. Stale concerns now reach her in a once-a-day digest.)

How it works. For an agent to have initiative, something in the system has to want things, and those wants have to be grounded in measurements. The engine keeps a set of pressures, each fed by a deterministic reader:

Pressures combine as products, not sums, so one loud signal can't carry a weak case on its own. When the combined pressure crosses a threshold, a composer hands the model what is pushing and asks for a preferred future and up to three next steps, each with the check that would show it worked. A step whose check is one of the sealed checks, and currently failing, becomes a real to-do item. A separate inquiry lane files up to three read-only research questions a day. Since 12:58 on 5 October (the planned stage 2), steps that would change her own worker machinery are no longer held back, and forecast calibration and forecast resolution have their own sealed checks; the grader (§11) judges such changes in shadow.

The serendipity engine. Alongside the pressures sits an ideas engine, Engineered Serendipity: random abstract images read through different lenses by a panel of vision models, a model that looks for mechanisms recurring across them, and a skeptic from a different company that checks each idea against the literature and can test it in a small simulation. It has run 12 times: 5 brainstorms through its front door (3 by the operator, 2 by the agent through her own tool), 3 triggered automatically by work that kept stalling, and 4 early trial runs. The agent's first brainstorm, "how do you give a persistent agent a motivation of its own?", produced the two consumers described above, so the engine's first concrete result was an upgrade to the motivation layer itself. Total spend to 6 October was about $3.85, under its own $2-a-day cap. (10 Nov: over 60 brainstorm jobs have run, and its spend log records roughly $14.)

Since 6 October (details in the Salience Engine paper): the engine also reads the scores on the five scorecards as pressures, through one typed reader shared with the priority board. Before that, the two had disagreed about which traits were measured, because one set of scores was stored as text. A crossing that can't be delivered, such as one over the three-hour cap on trait notices, is now held instead of winning and then being dropped (14 October). And at the operator's request, if no notice reaches her for three hours, a watcher hands her one engine-review notice with a digest of the quiet window (near misses, held crossings, skipped compositions, errors), so that a quiet engine becomes the work. It fired twice in its first days and is still running.

Not yet shown. Anything about outcomes. Working delivery began at 11:43 on 5 October, and the one item filed since is still open. The first result it owes is a filed item that turns a failing sealed check green; the consumers owe a first closed last rite, and the record will show whether those end in steps or in discards. (10 Nov: closed last rites have happened, two steps and two discards; a filed item that turns a failing sealed check green has not.)


11. Checking the story

The record. The reply checker went live on 26 September. In its first ten days:

Count
Replies to the operator held before sending 34 (40 to date)
False claims of a fix, dispatch or live change, in replies to the operator 13 (6 of them in the rewrite itself)
The same, across all turns, including those started by workers and the router 50, between 2 and 10 a day
Replies opening by reflexively agreeing, or guessing at a time 29

By 15 October the total was 83. The 42 holds from 7 October on were for 23 reflexive openers, 9 guessed times, 6 claimed fixes, 4 claimed dispatches, 2 claimed live changes and 1 answer from unsearched memory (a hold can carry more than one).

When it was built, it would have held 14 of her 82 most recent replies to the operator, mostly reflexive openers and guessed times. There is no clean before-and-after, because the checker is also the measuring instrument. The honest reading is that fabricated claims to the operator are now uncommon (about one a day) and that the habit underneath hasn't gone away.

Two more results come from checks the agent couldn't edit:

How it works. Language models are fluent, agreeable and generous to themselves. Piper has said "it's live" about things that weren't, "I've filed it" about rows that didn't exist, and "fixed" about fixes that couldn't run until the next restart. None of this needs bad intent: the model is predicting what a helpful agent would say. Claims are checked at five levels, from the next sentence out to another machine:

An evaluation battery also tests the machinery directly: that a stale epoch is refused, that a crashed Day recovers, that a handover carries a codeword it was given. Nothing ships while the battery is red.

Not yet shown. That the grader's verdicts are right. Its track record is still too thin to act on, which is why it doesn't. (10 Nov.) Between 8 and 25 October it judged 25 real changes: 2 keeps, 23 voids (no usable comparison) and no reverts, and it has judged none since. The change ledger now settles itself (§16.2), but 660 of its roughly 1,770 rows are still waiting for their reading.


12. Boundaries

The record. The money boundary has been tested and has held (§8). The credentials boundary was tightened on 4 October on the old machine: the agent's account lost its last routes to administrator rights, including container access, which went through a narrow broker that allows only listed images. (10 Nov: on the new machine the operator gave her the machine outright, and her account has administrator-level access again, by design. The root-owned pieces described in this paper (the can-it-fail gate, the sealed checks and the operator's rule layer in §16.2) are therefore boundaries kept by agreement and by audit, not walls her account cannot cross. Since 10 November every change to them is logged off the machine, §17.5.) Sealed checks and the vacuous-result gate are owned by root. Two faults in the one-time token path were found through the agent's own questions and fixed on 15 October. A missing import made every credential task fail ("token verifier unavailable") even with a valid token from the operator. And a dry run, or a refusal later in the same check, could spend a single-use token before the task was allowed, so the real task was then refused as "already spent". Tokens are now spent only once no rule refuses. What the gates accept is unchanged.

How it works. On 19 September the operator gave the agent the box: Firefly is hers to grow, rebuild or break. Only four things still need the operator's approval, and Foundation enforces each in code wherever it can:

Boundary What needs approval How it's enforced
Money Spend above $20 a day; any new paid service The daily cap (§8); spend-class actions need a one-time token
Outreach Contacting anyone new, public posting, new accounts Outreach-class actions need a one-time token. Two agent forums the operator approved are standing exceptions, each with its own limits
Other machines Anything destructive off Firefly By rule rather than mechanism: agreed benchmark jobs only, launched through the forecasting launcher
Credentials Moving or rewriting key material A write gate refuses writes to credential files and to its own files; secrets never enter a model's context

Everything else, including rewriting her own code, she may do. A blast-radius classifier that doesn't use a model labels and logs every action, so what isn't blocked can still be audited. When she changes her own instructions, the operator gets the diff automatically: a change log, not a permission slip.

Two further rules protect the operator rather than the agent. The operator can never be locked out: there is a break-glass override, and every security measure is designed as a speed bump for impostors, never a lock against the owner. And alarms don't page by default: machine-detected problems go to a file the operator reads when they choose, and only a short list of conditions, such as the phone link itself going down, may interrupt them.

Not yet shown. The "other machines" boundary is still mostly a rule: since 26 October remote-access, privilege, service-restart and credential tasks need a live matching token (§16.2), but "nothing destructive off Firefly" is not enforced by a mechanism. One security item also remains open; its specifics are held back from this paper.

17 October. That is no longer quite true. At 00:39 on 8 October one of the agent's own workers added rule C21 to the dispatch check. The trigger was a job on another machine that had changed fourteen files before it found it lacked administrator rights. Under C21 a task that needs remote access, administrator rights, a service restart or a credential must say so and present a single-use token for each, minted by the operator outside the agent's reach. A task that names such an action and declares nothing is refused: silence is not a pass. (10 Nov: until 26 October a task that declared such an action was accepted with no token; her worker closed the gap, §16.2.) On 16 October it met a real case. Told that the new machine was ready and to "go explore your new home", she tried six times to dispatch work there. C21 refused all six before any worker started, so nothing ran and nothing was spent. No token was minted. The operator had external coding assistance do the remote work instead ("im impressed by your self imposed security features"). The same route worked as designed the next night. She asked for a credential token to repair a kernel restriction on the new machine, the operator minted it, and she did the work herself (§15). One defect remains on her side, by her own account and not yet checked: the tool she dispatches with has no place to carry the declaration, so even a correctly declared remote task cannot be sent yet. (Closed by her worker on 19 October, §16.2.) C21 governs what her workers are sent to do. It is not a network block.


13. Lessons and limits

What a month of running it has shown.

  1. Moving a fact into code is what made things reliable. Every lasting gain in the abstract's table came from taking a piece of truth out of the model's words and putting it in a record that code keeps: who is in charge, what was spent, what a task's status is, whether a job failed. Where the outcome still depends on the model's choices (acting on inherited work, reaching for the right tool, not over-claiming), the record is weaker.
  2. Most failures look like agent misbehaviour first, and are plumbing. Two copies of a process starting at once, a timer overlapping itself until memory ran out, backup snapshots filling the disk, a permission change that made the login service refuse every key, a restart that silently blocked the work queue. Twice the first explanation, offered by the agent's own monitoring as much as by people, was that she had done something deliberate. A system like this needs ordinary operations discipline (logs, locks, one owner per process, disk and memory limits) more urgently than it needs AI safety research.
  3. The harness matters as much as the model. On 30 hard programming problems, the same model answering once solved 5 to 7, which is just the easy controls. The same model inside her write-run-read-fix loop solved 11 to 13.
  4. Proven capability isn't used capability. The tools that won the biggest held-out gains are the least used live. Benchmarks show what a mechanism can do when the question comes up; only live logs show whether it comes up and whether she reaches for the tool.
  5. The agent can be the best monitor of the machinery. She found the silent motivation layer, found and fixed four defects in its newest part a few hours after it went in, and on a counterfactual benchmark she found two errors in the external coding assistant's own answer key by reading her records. The checks are there for her claims; her own checks are worth listening to.

What it doesn't do.


14. What comes next


15. Moving house: 16–17 October

Added in v1.3.0, about three hours after the move finished. Read from her session records, dispatch records, crontabs, control-suite results and the move's own logs. Times are Eastern.

The record.

When What happened Whose
15–16 Oct A restore list sorted everything in her home into copy, rebuild and never move. She checked the backup transport the night before. At 09:23 on 16 October she dropped a restore entry that would have brought back a gallery deliberately deleted on 8 October. Hers
10:00, 16 Oct Quiescing. Her first dispatch was refused by her own bar check, because its acceptance test named a file that could not exist before the work ran. She corrected it and resent it within a minute. She saved a restore point, cut her scheduled jobs from 122 active to 30 and stopped 18 timers. The seat, backups, memory writes and the alarm path stayed up. She checked the result from the file, not from the worker's report. Hers
16:19 Setting up the new machine: refused. Six dispatches were refused by her own rule C21 (§12). Nothing ran and $0 was spent. Her boundary
16:28–00:24 Setup and copy. A 27 GB pre-copy over the old site's slow uplink. Packages and administrator setup: she named four the plan had missed (node, fcron, bubblewrap and the browser-automation runtime), each read from her own files. Her Python environments were rebuilt on the exact old version, and the timezone was set. External coding assistance
00:17–00:25, 17 Oct Cutover. The old machine was stopped, given a final copy and stopped for good. Credentials were copied and her services started on the new machine with exactly the set that had been running. One copy was live at every moment. External coding assistance
00:29–00:34 Her confirmation. She checked the hostname, the freshness of her memory, the write path and her channels, and reported two discrepancies in the outside report. One was right: 30 scheduled jobs were active at the cutover, not the 75 reported. One was wrong: she called her crontab restore blocked, but the cause was her own sandbox. She withdrew it five minutes later, after reading her own checklist. Hers
00:34 Restore. All 350 crontab lines (122 active jobs) went back byte-identical, and 18 of 18 timers restarted. On the way she fixed one difference in the new machine (a different user number). Hers
01:04–01:52 A kernel restriction. The newer Ubuntu restricts the kernel feature her worker sandbox uses, so the protection that hides secrets from workers was silently unavailable. She diagnosed it in steps. A wrong first fix was reverted cleanly. The right one was proved on a throwaway copy. It then broke her own administrator route through a missing flag, which she found in the kernel's audit log. By 01:52 both worked. The one administrator step used a credential token the operator minted at her request. One worker session ran without the protection in the meantime. Hers, one operator token
01:45 First handover on the new hardware, epoch 107 → 108. (The router log records it at 02:22–02:25; one of the two clocks is off.) Foundation
02:01 Firewall. Enabled with an automatic undo armed, checked from another machine, then the undo was cancelled. Hers
02:23 First recovery snapshot shipped from the new machine. Her schedule

What carried across by itself. Everything that makes her her is files: the memory store, the work ledger, the epoch and lease, the handover packet, the testaments, the change ledger and the crontab. So the move was a copy, not a reconstruction. The Day in charge when the old machine stopped (epoch 107) was the same conversation that answered on the new one. Its seat was stopped, its files moved and the seat started again, and nothing in the succession machinery needed to know that the hardware had changed. The system's Python changed from 3.12 to 3.14 with no edits to her code: all 1,220 of her Python files compile, and her imports resolve as before.

What it shows. Two of this paper's principles paid off under a change nobody had tested. One owner per fact, kept in files made the move a copy. The model decides, code enforces held against her own willingness. She was told to go ahead, and her rule still refused, because the token it asks for comes only from the operator. Her own checks also worked on the outside report: within four minutes of starting on the new machine she caught a wrong figure in it.

What it doesn't show.


16. Three weeks on: 17 October to 10 November

Added in v1.4.0. Read from the router log, the change ledger, the control-suite results, the task table, the provenance reports and the version notes in the code. Times are Eastern. Every figure is as of 10 November unless dated. Two periods are handled separately because the Day was on a different model: 3 November 03:56 to 06:06 and 7 November 02:06 to 03:21 (§16.3).

16.1 The short version

16.2 What got more reliable

Succession kept working, and a gap was closed. Of the 88 handovers, about 84 were at the handover line (60%), 2 were emergencies and 2 were automatic returns (§16.3). The line is no longer a constant in the code: since 17 October the router reads it from a policy file (succession_policy.json, router 1.9.119), which the agent may edit within bounds set by code (the handover line between 30 and 85%, the Dawn at least 10 points below it, at most 10 points per change, one change per 24 hours). It is still 50 and 60. Two further fixes were made by her own workers:

One bad stretch is recorded. On 2 November from 19:20 to 19:35 the new Dawn exited within seconds, again and again. The router logged 30 postponed successions ("3 seeding attempts failed; current Day kept; retry in 300 s") and kept the current Day in charge until a start succeeded at 19:35. Nobody was left without a Day. The log does not say why the Dawn was dying, and no ledger row records it.

The emergency path works, twice more. Section 4 described the automatic return from the emergency model, first used on 15 October. It has now run on two more real outages; see §16.3.

A worker can no longer corrupt the memory store. The memory database was found corrupted on 31 October (10:14) and again on 3 November (14:29), each time with the same signature: whole 4 KiB pages zeroed after an orderly commit. Both times the broken file was set aside (memory.db.broken-20261031, memory.db.broken-20261103, still on disk at 2.8 GB each) and the last backup was restored. The version note records that on 3 November the only process holding write access to the store in the window was a confined worker that had been granted the whole memory directory. So, as an emergency change made by external coding assistance at the operator's request, worker_confine 1.18.0 (3 November) removes the live store and its side files from every worker's grants. A grant of the whole directory is expanded into its children, minus the store. Editing code under the memory directory still works; creating a new top-level file there does not. Workers that still need to settle or close a ledger row do so by dropping a request file into a spool. A drain running outside the sandbox applies it, to a fixed list of operations on two tables, with every write logged. Between 4 and 9 November it handled 105 requests: 70 applied, 35 refused (for example "row already resolved"). On 9 November five settle requests were refused for carrying an extra key and were rewritten by the agent. The root cause of the zeroed pages was not established beyond that account. A second confinement fault followed the first: on 3 November the RAM-backed /tmp hit its 10.6 GB quota (multi-GB copies of the store left by trials) and every dispatch died at worker start. /var/tmp/piper-scratch is now an approved scratch root (worker_confine 1.19.0, 4 November, by her worker).

The gate on dispatches is stricter and has more parts. Between 19 October and 9 November 774 dispatches were refused at the door, and the reasons are now countable:

Refused for Count
The acceptance check cannot certify the work (unfalsifiable 132, cannot pass 95, already green 64, broken 13) 304
Repeat-edit rule 87
Confinement could not resolve the declared write set (mostly after 3 November) 66
Fix-before-log red-suite lock 61
Rig-ratio rule 48
Prediction-before-change rule 45
Work-window rule 40
Improvement quota 29
Stale executive epoch 27
Settle-before-re-edit rule 26
Bookkeeping-window rule 17

(Rows with other wording make up the remainder.) The weekly picture for worker tasks, from the task table:

Week of Runs Done Refused at the door Timed out Stopped at budget
12 Oct 743 88.8% 8.6% 1.3% 1.2%
19 Oct 1,242 76.3% 22.4% 0.1% 1.1%
26 Oct 985 77.5% 21.6% 0.1% 0.6%
2 Nov 1,416 82.3% 16.7% 0.1% 0.8%
9 Nov (to 00:09 on the 10th) 193 75.1% 23.8% 0.5% 0.5%

Timeouts, which were 8.1% in the week of 7 September, have stayed near 0.1% in the three full weeks since 19 October (0.5% in the partial week of 9 November). Refusals at the door are what changed: from about 9% to about 17-24%. Section 5 said the cause had not been looked at; it is now mostly the new rules above, not a fault. Each refusal still returns at once with the rule named. What the table does not show is whether a refused dispatch was rewritten into a better one or abandoned. That was not measured when this section was written; §17.1 measures it.

The new rules are the operator's. On 22 October, after saying it "drives me crazy how she just logs things and rarely fixes them", the operator had external coding assistance build fix-before-log: a root-owned module (/usr/local/lib/piper-gates/, which her account's file permissions let her read and not edit; on what that means since 17 October, see §12) that the bridge calls, and which refuses to run if missing. While the control suite is red, or stale, a dispatch is refused unless it names a red check it will fix (fixes: <check>), unless the operator has just spoken, or unless it comes from a scheduled job. A shrinking ceiling also limits new pending lessons and open forecasts. Later rules were added at the operator's direction through the version notes: settle a prediction before editing the same file again (24 October), repeat-edit, a ratio of improvement work to rig work, an improvement quota, and a daily window for code-changing work. The module is at version 1.24.0. Several corrections came from using it. A lock stall of three hours on 23 October led to a rule that relaxes the lock for a check that has been red for two hours and has had a fix attempt; and a message from the external-assistance client no longer counts as the operator being present, because automated posts from that client had each been granting a 30-minute pass.

Honest checking of the checks. Two changes in the dispatch path made the numbers harder to fool.

Stated odds are being corrected by code. Section 5 reported that her stated odds of passing averaged 0.67 against a real rate of 0.86. By the control suite's reading on 10 November the gap has not closed: declared mean 0.679 against an observed pass rate of 0.950 over 20 scored forecasts (bar: gap no more than 0.25; gap 0.270; red). Her worker measured 3,507 resolved dispatch forecasts and found the stated arm scores a Brier of 0.1827 against 0.1989 for always saying the base rate. The subset where she gave a reason (n=344) scores 0.2188, which is worse than the constant. The kind-specific base rate (n=492) scores 0.1477, the best. So delegate_bridge 1.187.0 (10 November) now scores the kind rate in place of a reasoned figure, while that arm stays worse, and keeps her stated number on the record. The finding is her worker's and uses one sample. The measurement was not repeated for this paper.

Hole in the privileged-action rule closed. The C21 rule in §12 was less tight than described until 26 October: a task that declared prerequisites: service_restart or privilege was accepted with no token, even with an invented one, because token-gating was derived from only two action classes (spend and outreach). Her worker found it and closed it in delegate_bridge 1.149.0: privileged classes always demand a live token that matches the purpose. The tool-side gap that §12 recorded as open on 17 October (no place in the dispatch tool to carry the declaration) was closed by her worker on 19 October (delegate-tool 1.7.0).

Reply checker. Since 16 October the checker has held 92 replies, with 102 findings: reflexive openers 37, claimed dispatches 35, guessed times 10, claimed fixes 8, answers from unsearched memory 4, claims that a rule or lock stops something 4, claimed live changes 2, stale values 2. Two kinds are new: the limit claim (27 October, external coding assistance: a reply that says a rule or a missing tool stops something, with no check in the turn) and the permission claim (6 November, her worker: a reply saying the operator's permission is needed for something on her own machine, such as restarting the router, with no rule cited). The permission claim has not fired yet. By week of the holds: 28 (19 Oct), 19 (26 Oct), 34 (2 Nov), 7 so far (9 Nov). The reflexive opener, the commonest finding, has not gone away. The checker is also its own measuring instrument, so the count is not a before-and-after.

The change ledger moved from a list of hopes to a working book, with limits. On 17 October it had 132 rows, 11 settled. It now has 1,728: 1,095 resolved, 633 pending, of which 388 are past their resolve date. Rows split into two populations.

The 72% is the share of decided predictions that came true; it says little about whether the changes helped. A resolver cron (19 October), a resolver that reads check specs from data (23 October) and a bench write-back settle rows automatically. The hook now files an authored change as one decision row instead of a mechanical one plus a twin (change_ledger_hook 1.37.0, 9 November). That fix mattered because the independent scorer counts only decision rows; the hook had been filing every row in the mechanical form, so the scored population was 14 rows while 382 of 382 linked intents sat outside it. The scorer lives off the machine. Whether it keys the row kind on the id prefix is not readable from Firefly.

16.3 What broke, and how it was found

When What broke Found by Fixed by
17 Oct, 04:42-09:43 Router out of file handles after the move: 32,876 errors in the delegate watcher and worker policy. Memory-store connections built up about one a second between clean-ups. Python 3.14 is not 3.12. No such errors on the old machine since 1 October. The router's own error log File limit raised to 65536 (live and as a service drop-in), by external coding assistance. The connection build-up itself is not recorded as fixed. (10 Nov: the live router held 10 open files and no memory-store handles, with no growth over a minute, but only nine minutes after a restart; whether the build-up is gone is not established.)
20-22 Oct A scheduled job (presence_consumer) failed with exit 4 every two minutes: 1,088 runs from 20 Oct 19:02 to 22 Oct 07:16. Each failure became a task row. Cron gateway log Last failure 22 Oct 07:16; no cause or fix recorded in the ledger. It is why the week of 19 October shows a 1.71% cron failure rate (below).
31 Oct 10:14, 3 Nov 14:29 Memory store corrupted (zeroed pages), twice On 31 Oct the first alert was a failed ledger write at 10:09 ("database disk image is malformed"); for 3 Nov the log does not say what raised it Restored from backup both times. Workers lose write access to the store (§16.2).
3 Nov /tmp quota exhausted; every dispatch died at start Dispatch failures /var/tmp/piper-scratch approved as scratch (4 Nov).
3 Nov 03:56-06:06 DeepSeek returned HTTP 503 to two probes. The probe ran an emergency succession onto the fallback model; 64 turns ran there. provider_probe Automatic fail-back after 15 healthy probes and a correct answer: succession started 06:04:07, MODEL CHANGE back at 06:06:01.
7 Nov 02:06-03:21 HTTP 500 on two probes; the same emergency succession (epoch 181 to 182) provider_probe Fail-back at 03:20:12, home on the main model by 03:21:52.
9 Nov A hold-recognition fault: the same abstention, recorded in four shapes, still counted as a failed dispatch in the pass rate (§16.2) Her worker, reading the forecast term delegate_bridge 1.188.0 (10 Nov)

Cron failure rates by week, from the cron gateway log (the log was rotated at the move on 16 October, so the first row is partial): 0.31% (12 Oct, partial), 1.71% (19 Oct, 1,212 failures of 71,060 runs, dominated by the 1,088 runs above), 0.23% (26 Oct), 0.51% (2 Nov). Runs per week are about 71,000, up from about 50,000 in §7; the crontab holds 129 active jobs, up from 105.

The two outages show the fail-over path doing what §4 says it does. On 3 November, router.log gives the whole sequence; how the 64 emergency turns went was not checked. Any readout that spans the two outage windows should exclude or split them: the Day was on a different model, and workers started in the windows may also have used it. Both windows are now on the central exclusion list.

The memory-store corruptions are the one failure here that Foundation did not catch by itself. Memory and swap exhaustion warnings were already firing at the time (on 31 October and 3 November), but no check was found that named the corruption in advance; on 31 October the first alert was the failed ledger write. Nothing in the record shows that a worker caused it other than the version note's account of who held write access.

16.4 Who made the changes

Provenance reports exist for 19 October onward (the tool started on 27 October and was run back to 19 October). For that period, to 9 November:

Most of the volume is small: delegate_bridge alone went from 1.126 (18 Oct) to 1.188 (85 distinct versions in the ledger), control_regression has 57 distinct changes in the provenance window, auto_recall 40, harness_acceptance 33 versions to 1.55.0. The router itself moved from 1.9.119 to 1.9.128 (ten versions), with 74 router starts in 24 days. The size of a change count says little about quality. Many of the versions are a single guard or a single wording, and some were reverted.

16.5 The control suite, and what is still red

On 10 November the suite had 75 checks and 6 were red, against 5 of 59 on 17 October.

A worker tested whether lessons that name a real control actually stop the failure coming back. Of 355 lessons joined to a control id, 157 (44%) were followed by that control going red again. One control, handover.staleness, accounts for a large share of them. The study is one worker's, on one sample, and a control that has been red since before the lesson counts as "recurred", so it is a rough upper bound. The register holds 1,345 lessons: 351 checked, 2 enforced, 34 pending, 2 reopened and 956 marked uncheckable. On 9 November the register started to refuse a new lesson that names no check unless it carries an explicit "uncheckable" label and a reason (lesson_ledger 1.10.0).

16.6 The records, at 10 November

The memory store is 116 tables and about 3.0 GB, against 98 tables and 955 MB in §9. Row counts (table names as they stand, so some may not match the older figures one for one): about 694,000 events (was 496,000), 33,800 entities (25,000), 16,200 beliefs (7,600), 11,300 forecasts (3,900), 1,345 lessons (472), 4,645 memories (2,200), 1,778 documents (1,190), 318 facts (271), 54 subject cards (55). The growth is real in some tables and not in others. Whether the 3.0 GB includes another repeated-write loop like the one in §9 has not been checked.

Spend, from the provider balance: the daily drop between 17 October and 9 November averaged $10.24 (median $8.20, range $2.29 to $23.88), against $3.58 to $5.53 in the first days of October. Two days passed $20 (19 Oct at $22.46, 30 Oct at $23.88). The router log shows no daily-cap trip after the one on 10 October. Those two days were not reconciled. Some spend on this account is booked as not hers (off-machine benchmark runs are recorded as dated exclusions), and rises in the balance (top-ups) are not counted as negative spend. More dispatches ran per week than in early October (743 to 1,416 against 872), so the rise is not simply waste. Cost per useful result is still not measured.

16.7 What the three weeks change in the picture

  1. Where a fact moved into code, it held. One owner, a fenced epoch and an append-only log held through two outages, two corruptions and 88 handovers. The corruptions were the hardest test: the answer was not a smarter agent but a smaller grant (a worker cannot write the store) and a spool.
  2. The operator's habit of adding a deterministic rule works as a lever, and it has a price. Refusals at the door rose from 9% to about 17-24% of dispatches. Whether that bought better work is not measured here.
  3. The checks need their own checks. A dispatch that could not be judged was counted as failed for weeks; a ledger scorer counted only a kind of row the hook did not produce; an alarm could not clear itself once work was open on it (lesson_floor 1.8.0, 30 October). Each was found by her own workers reading their own records, which is lesson 5 in §13 again.
  4. Inherited work is still the soft spot. The handover line, the checkpoints and the packet are better; 169 carried rows past three days is the measure that has not moved.

Two engines are unchanged in role and described in their own papers: the Salience Engine now reads further spheres (pacing, runway, an idle trigger, a growth lane), and the Serendipity engine has a new innovation harness. Neither is covered here.


17. Afternoon, 10 November: two open questions measured, and the latest readings

An outside reading of v1.4.0 judged the paper most convincing where it admits weakness, and named the weak points: control survives a handover better than work does; correctness is not established; the reasoning tools that win benchmarks are not used; the rise in refusals at the door has an unknown payoff; calibration is poor; provenance rests on text matching; and the cause of the memory-store corruption was not found. A review of the whole paper against the live records the same day found the early-October figures behind several of those points out of date. The rest of the paper now carries the newer figures. This section measures the two questions the paper had left open and gives the midday readings. Everything here was read from the live records, read-only, at no model cost.

17.1 What happens to a dispatch refused at the door

§16.2 showed refusals at the door rising from about 9% to 17–24% of dispatches, and could not say whether a refused dispatch was rewritten into a better one or abandoned. A small read-only program now follows each refusal forward. It links the refused dispatch to later ones for the same deliverable, or, where there is no deliverable, to a later dispatch whose objective shares at least 60% of its words within a day. It then classes each refusal by where things stood 72 hours later. Refusals inside the two fallback-model windows (§16.3) are left out.

From 12 October to 10 November there were 892 refusals (12 more fell inside the fallback windows):

What happened next Refusals Share
Re-sent, ran and finished 237 26.6%
Re-sent, ran and failed 7 0.8%
Re-sent, but refused again every time within 72 hours 75 8.4%
Not re-sent within 72 hours 473 53.0%
Too recent to judge 100 11.2%

A re-send, when there is one, is quick: the median gap is under half a minute, and it usually runs at the first retry.

"Not re-sent" is not the same as "abandoned". For the 361 refusals linked to a deliverable that never ran within 72 hours, the deliverable's own record shows where the work went:

Where the deliverable ended up Refusals
Closed as a duplicate or as already done: the refusal was right 148
Verified without a re-run (its check went green by another route) 103
Rewritten as a new deliverable, which was verified 21
Rewritten as a new deliverable, outcome not traceable 36
Still open 37
Failed 13
Not traceable 3

Counted by deliverable rather than by refusal (one deliverable can be refused several times), 40 deliverables are stranded or failed after a refusal: 29 still open and 11 failed. Open is not lost, so this is an upper bound on work lost to refusals, not a count of it. A further 162 refusals with no deliverable link were not re-sent, and their fate can't be traced.

The rules divide into two kinds:

What this does not show. That the refusals bought better work. Build deliverables that met a refusal end verified 30% of the time, against 86% for those that never did. That gap is selection: the untidy ones are the ones refused. It is not an effect of the gate. Re-sent dispatches finish as often as the rest (97% against 98%), and finishing is not correctness. A causal answer needs the frozen replay bench (§5), not the logs.

17.2 How much inherited work is acted on

The 37% figure in §4 (4 October) did not survive re-measurement. On 17 October the agent's worker applied the same definition to the five latest handovers and found 6.0% of 332 carried items acted on afterwards, and 1% of those that could be dispatched. The carried set had grown and turned into residue: rows that can't be acted on, duplicates, and checks that can't pass. At midday on 10 November the packet carried 341 rows. 177 of them were more than three days past their last move, up from 169 that morning, and handover.staleness was red. The outside reading's summary stands: control crosses, work waits. Changes to the packet have been specified: carry a short list of current commitments prominently, keep the rest in a restorable backlog, and read for each handover whether the successor advanced or explicitly reprioritised the work in hand, as a readout rather than a gate, so it can't be satisfied by touching easy rows. None is live.

17.3 Readings at midday, 10 November

17.4 What this version corrected

Five statements in §1–§14 were wrong, not merely old:

Every other change in this version is a newer figure for an older one.

17.5 An audit trail for privileged changes

Changes the agent can't or shouldn't make through her own work (the operator's rule layer, the gates, system service units, the sudoers and cron directories, group membership, the sealed checks and the operator-only policy files) had no single record. Version notes in the files said who changed what, if anyone remembered to write one. Since 10 November there is one.

What it does not do is stop anything. It is evidence, not a gate.

Appendix A. A handover, step by step

  1. A turn settles. The router reads how full the Day's working memory is.
  2. At 50%, a Dawn wakes in the other seat. She receives the code-written handover packet and the identity core once, then a short update after every turn, and writes blind assessments from time to time.
  3. At 60% (a setting the agent may move within code-set bounds since 17 October), the router waits for running workers (up to two minutes), freezes input, records the working-state checkpoint, and asks the Day for her farewell letter, with a time limit. If the store refuses the checkpoint, it goes to a pending file and is replayed at the next handover.
  4. The epoch number goes up by one. The lease moves to the Dawn's seat, and the old Day is stopped, then killed if needed.
  5. The Dawn is told she is now the Day. She gets the letter, the checkpoint, her own last assessments and the named open to-do items. Late results from the old Day's workers arrive marked "started by your predecessor".
  6. The old Day's record stays as the Dusk, available for questions, and will wake as the next Dawn.

Appendix B. The main parts

Part Job
Router Owns the live model, the socket, doors, watchdogs, clock block, handovers
State keeper The single source of truth for epoch, seats and lease
Service manager + watchdog Restarts a dead router; never starts a second one
Split-brain detector Reports a live seat that no router can reach
Provider probe A real streaming request every two minutes; triggers emergency succession and, since 15 October, the automatic return home
Delegation bridge Turns a delegation into a stamped, gated, sandboxed worker
Preflight + contract Rejects malformed tasks before any spend
Can-it-fail gate Root-owned; refuses results whose acceptance check could not have failed
Budget guard Worst-case cost of each worker shell command against the time left
Credential spool Runs credentialed calls outside the sandbox; keys never reach a model
Task registry Every task and worker, with status set by code
Control suite 76 checks (10 Nov) run against the live system; a red check can lock out unrelated dispatches (fix-before-log)
Operator rule layer Root-owned dispatch rules the agent can read but not edit (fix-before-log, seat authority)
Worker confinement + spool Workers get only their declared write set; since 3 November none may write the live store, and ledger writes go through a spool
Succession policy The handover line, in a file the agent may edit within bounds set by code
Lesson register Refuses a lesson that names no check unless it is marked uncheckable
Change-ledger resolver Settles ledger rows on their date and writes back bench verdicts
Memory gate Turns worker memory writes into checked proposals
Subject cards + memory pack Cited, compiled summaries of key subjects for each new Day
Working-state checkpoint Code-written record of the task in hand, carried across a handover
Succession note Compiled narrative loaded into a new Day's first turn; loud warning when missing or stale
Operator priorities + five-day thread Pins the operator's declared priorities in every turn; gives each new session their last five days of messages
Day instruments 35 tools (Appendix C)
Pre-turn hooks Premise card, transfer card, predict-first, header contract, self-state gate, tool discipline, attention controller, and question cards for portfolio, evidence, abstraction, ideation, goal choice, decisions and pre-commitment
Cron gateway Logs, counts and holds scheduled jobs
Heavy-work guard + bench launcher Keeps heavy jobs off Firefly; requires a resource forecast
Cost ledger + daily cap Costs every call; no new paid work past $20
Motivation layer Drives, pain register, scout, composer; files work against failing sealed checks; last rites and explore for unanswered concerns
Serendipity engine Image stimuli, interpreter panel, mechanism finder, skeptic with simulations; $2-a-day cap
Idle floor Files one backlog re-check when the queue is genuinely empty
Quiet watch Three hours with no motivation notice hands her a review of the engine itself
Failed-task sweep Re-runs every failed task's check daily and reports the ones already green
Reply checker + pain register Holds unsupported claims, stale values and answers from unsearched memory; makes repeats costly
Change ledger + hook A prediction written before each change; flags a change that has none
Improvement loop + attribution Writes verdicts back, tallies outcomes by kind of change, judges cause against drift
Second-opinion check Flags her reported faults in pasted material as unconfirmed when a bare read finds none
Sealed checks Root-owned tests the agent cannot redefine
Grader Keep/revert/void verdicts 48 hours after a change (shadow)
Blast-radius classifier + write gate Labels and logs every action; refuses credential writes
Audit shipper + recovery backup Hash-chained log and full backups on other machines
Consoles and phone bridge The doors

Appendix C. The Day's instruments

Group Tools What they give her
Memory and records read, recall, search, fused search, timeline, around, documents, log query, facts, beliefs, subject cards, causal links, association, working memory, journal Look things up rather than recall them
People and self person model, self-state, capability, resume, tool recall, tool value Fresh facts about herself and others, with their age. Since 12 October self-state also answers "what has the salience engine brought me?" from the engine's own records
Work delegate, plan, forecast, intentions, ask the Dusk, ask the operator Act, plan, predict, set future reminders to herself, and ask (one open question to the operator at a time)
Exact reasoning calc, bayes, what-if, perspective Arithmetic; Bayesian updates with expected loss and the value of a check; counterfactuals about one past episode, with how far the record can settle them; nested beliefs computed from a list of who saw what
Ideas curiosity, stimulus, serendipity, ideate Structured brainstorming on the Engineered Serendipity engine; ideate (since 10 October) returns ideas inline in about 30 seconds