prospectus_draft.md

Prospectus draft (content pass, no design)

Status: page 1 awaiting her markup (research-question-first revision, may shrink now that page 2 carries the how); page 2 drafted per her ruling that reviewers need HOW it is designed, not why. Simagotchi sentence still held for her ruling. Ask structure (sequenced vs consolidated) open; budget page inherits the answer.

Page 1 — What this is

This is a prospectus for an experiment.

The question: can a deliberately organized population of heterogeneous AI processes, differentiated, persistent, and selectively autonomous, constitute a coherent digital cognitive system with properties that do not arise in conventional single-agent or multi-agent designs? The analogy underneath the question is organizational, borrowed from biological nervous systems and treated strictly as a hypothesis-generating framework: differentiated cells, division of labor, signaling through a shared substrate, inhibition as well as activation, development through accumulated experience. Whether the analogy holds is the thing being tested, and it cannot be tested by theory alone. The object has to be built before its properties can be observed.

The apparatus already has a full design. Every action any agent takes is written to an append-only record with two mandatory fields: who acted, and why. Agents do not converse directly; they are summoned briefly, read the record, act, deposit, and end, so continuity lives in the record rather than in any running process. Agents cannot summon agents; only code holds that key. Nothing runs unsupervised past a dial the operator sets. Nothing persists unless persistence is deliberately granted, and anything granted can be reviewed, revoked, or reverted, with the reversal joining the record rather than erasing it. A human can occupy a working position inside the same cycle, which makes human participation an experimental variable rather than an external assumption. These are not policies layered over the architecture. They are the architecture, and they double as its instrumentation.

The interface wears all of this like a game, because that is what an interface honestly is. A new user is greeted, asked for a moment of their time, asked what kind of movie they like, and given a room built in that style, with the system’s reasoning in a ledger one click away and every change reversible by hand. It belongs to a genre I have been calling the simagotchi: a small simulated society you keep, tend, and are known by. [SENTENCE HELD FOR HER RULING]

The research program sweeps one variable: the number of humans present. One, living with the system daily. Several, as host and guests in a shared instance. Zero, in an autonomous arena observed rather than steered. The same record instruments every configuration, and disagreement between independent assessors, not consensus, is the primary measurement. The outcome is unknown, and negative results are results; what is promised is discriminating, reproducible evidence.

Two commitments govern the work. The ethics of this design do not change between versions; mechanisms will be revised, and the process is built to revise them, but sovereignty, dignity, and consent run through every version or the version does not ship. And nothing is instantiated before the infrastructure to hold it exists, including an independent security review of this design before any agent runs live.

I will build this regardless. What funding purchases is not the idea but the investigation: continuous, full-time, instrumented, and reviewed, instead of incremental years around outside employment.

The pages that follow show the demonstration, the program, the schedule with its gates, and what it costs.

Page 2 — How it works

The system is built from four concrete parts: a record, a set of seats, a summons mechanism, and a wheel that sequences them.

The record. Everything the system does is a write to an append-only log, committed like source code, one commit per turn. Every entry carries mandatory fields: a timestamp, the actor that acted, the action, and the reason. There is no other channel. A representative slice, from the demonstration:

20:14  user      style order          reason: M (1931), described then named
20:15  greeter   correction offered   reason: accuracy is kindness
20:15  greeter   inference logged     reason: salience: "kangaroo court"
20:16  wheel     build room           reason: showing the user what was heard
20:17  user      style note           reason: reads as Young Frankenstein
20:17  wheel     re-render room       reason: went underground, lowered resolution

Because the record is the only channel, the record is also the instrumentation. There is no separate telemetry to build or trust; the data of every experiment is the system’s own history, complete by construction.

Seats and bindings. A seat is a named role with a written contract: what it reads, what it may do, what it must deposit. A binding attaches a specific model to a seat: provider, model, chat or raw-completion mode, behavioral dials, cost table, capability flags. Creating a binding fires a handshake, one small real call that verifies authentication, mode, and capabilities, and logs its actual round-trip cost. Seats and models are deliberately separable: swap the model, keep the seat, and you have a controlled experiment. Renaming aliases forever; seats retire but are never deleted, because deletion would falsify the record.

The summons. Agents are not running processes. A model is summoned for a single call: it receives its role, a packet of relevant state, and its dials; it reads, acts, deposits, and ends. Agents never talk to each other directly and cannot summon each other; only the system’s code holds the summon key. Coordination happens the way it does in an ant colony: one process leaves a structured deposit, a later process encounters it and acts. Continuity therefore lives entirely in the record, not in any resident program, which is what makes the population safe to stop, swap, and restore at any commit.

The wheel. A revolution is one lap of work: a deposit arrives, the next seat is activated, it reads the current state, performs its differentiated task, deposits, and the deposit becomes input to the following seat. A human can hold a seat and take turns inside the same cycle, under the same logging. Wheels park at defined boundaries and wait; a dial caps how long anything may run without supervision. At current API pricing, a fully verified revolution costs roughly 17 cents on frontier models and about a nickel on budget models, versus about six and a half cents for a single unverified frontier call; verification is roughly forty percent of the cost, and it pays for itself if it catches one error in six turns.

Permissions. Elevated capability exists only as an explicit human grant carrying scope, duration, and reason, expiring by default, revocable, and non-transferable; an agent cannot delegate what it holds. Scope is checked by code at the moment of each privileged call, not just at provisioning. Because grants are record entries like everything else, “what can touch what, right now” is a single query, and a grant left untouched past its horizon surfaces for reconfirmation instead of quietly persisting. Neglect decays toward revocation, never toward standing access.

Verification and measurement. Separate seats verify and audit, and the design treats disagreement, not consensus, as the primary signal, since agreement between similarly trained models can be contamination rather than truth. Disparity is measured between assessor pairs, and against an unconditioned cross-family control: if two conditioned models converge while the outside control holds steady, that pattern flags conditioning, not correctness.

Memory and reversal. Nothing persists unless persistence is granted; ephemeral work evaporates by default. Certified checkpoints plus a deliberately simple restore tool make any state recoverable, and reverting is itself an append, so history grows and is never rewritten. Settled practices are written down as standard operating procedure files at the moment they settle, so the system documents itself as a side effect of running.

The demonstration described in the next section is these mechanisms and no others, rendered playable: the record on screen, one click away, while a new user is greeted, asked, built for, teased, corrected, and handed the revert switch.

Page 3 — The connective layer

The hypothesis at the center of this project is about data, not models: that cognition, if it emerges here at all, will live in the way knowledge is connected, and the models are transient processes passing over that structure. The models are interchangeable and ephemeral by design. The persistent object is a growing graph of connections, and the graph is built like a library, because it is one.

Connections are files, and the filename is the synapse. Every learned relation between two concepts is stored as its own file, and the relation lives in the name itself: an address number, the two concept codes, the relation term, and the mechanism, in the pattern [number]_[node]_CONNECTS_[node]_BECAUSE_[mechanism].md, machine-timestamped at creation. An agent browsing the folder sees the shape of what is known without opening a single file, which makes reassembling context cheap: the connections are the summary. The design principle behind this is blunt: compression destroys the connections between things, so the system stores the connections themselves as first-class objects rather than trusting any process to reconstruct them.

The vocabulary is engineered against drift. Relation terms come from mathematical usage rather than conversational English, because colloquial words carry inferences that mutate as different models read them. Concept names in filenames are short codes resolved by a registry, and new relation operators enter the vocabulary only through a human-approved proposal. The mechanism field stays in words, because the why is the part a future reader most needs.

The addressing is Dewey. The numbering is decimal-insertable: new knowledge shelves between existing entries without renumbering anything, the way a library slots a new book between two old ones. This is not a nostalgic flourish; it is the property that lets the graph grow for years without reorganization ever becoming destruction. Subject locality does the rest: related connections shelve near each other, so densely connected neighborhoods form around the concepts the system actually uses, and a neighborhood of the shelf functions like a region of the graph. Reorganization, when it happens, is a single versioned transaction: files move, the manifest heals, existing connections are reconfirmed under the new scheme, and any edge that fails re-reading is superseded honestly rather than silently carried forward.

Python is the enforcement layer. Plain scripts do the unglamorous constitutional work: validate names against the grammar, stamp the timestamps so no model ever invents one, maintain the code registry, run the reorganization transaction, and refuse malformed writes. The choice is deliberate: the connective layer must outlive any particular model, framework, or vendor, so it is built from files, names, and a small amount of boring code, with a migration discipline already written for the day something replaces the stack.

The analogy, stated carefully. A reasoned, typed connection resembles a synapse. A summons reading a neighborhood of the shelf resembles a region activating, and the per-call manifest records exactly which neighborhood lit up. Appending and reconfirming connections resembles plasticity; the dormancy cycle resembles pruning; the standard-operating-procedure files resemble consolidation. Whether these resemblances are load-bearing or decorative is precisely what the experiments test, and the layer makes the test concrete: the same agent population can be run with the connective layer and without it, and the difference in continuity, retrieval, and behavior is the measurement. If the graph is doing nothing, the ablation will say so.