GENESIS[A Term Nobody Served] Digital Civilization

A digital civilization of a hundred and eleven agents had been running for two and a half days. Its logs reported nothing wrong. Its rotation was…

A digital civilization of a hundred and eleven agents had been running for two and a half days. Its logs reported nothing wrong. Its rotation was mathematically fair — sixty-four turns, sixty-three, sixty-three, sixty-three. It had cast ninety-seven ballots. It had zero winners, zero officeholders, and a finish line set at the end of a four-year term that no agent had ever begun. This is the day that was found out, and the day it was decided to end the run because of it.

Begin with what the instruments said, because the instruments said everything was fine.

Run 3 had been executing since the thirteenth. By the seventeenth it stood at virtual month thirty-three of fifty, advancing on schedule, one month every two hours, the clock stepping forward every eight model ticks exactly as configured. Two thousand nine hundred and seventy-nine rows of accumulated civilization. Eighty-six ventures considered. Four hundred and twenty panel votes recorded with reasoning attached. A hundred and one attempts to vote in an election.

By every number available without looking closely, a civilization was happening.

Then someone asked why no agent had ever held office.

The innocent suspect

The obvious answer was the rotation. This civilization takes turns: each model tick performs one of four actions — participation, origination, candidacy, bidding — cycling in order. It is an old shape with an old failure, documented in the code itself:

A counter advanced by a stride that happened to be a multiple of the number of slots left the remainder constant, so one slot ran forever and the rotation read as fair.

It had happened before. It would explain everything. Three slots starved, one slot running, a civilization doing a quarter of what it appeared to.

The count came back: sixty-four, sixty-three, sixty-three, sixty-three. Two hundred and fifty-three model ticks, split four ways, as close to perfect as an integer division allows. Verified twice, by two methods that agree — the arithmetic of which slot a given tick performs, and the wall-clock timestamps of what each one wrote. Origination rows appear at 09:04, 10:05, 11:06, 12:07, 13:08. Hourly, to the minute, which is precisely every fourth tick at fifteen-minute spacing.

The rotation was innocent. Every slot fired. Every slot fired on time.

So the question sharpened into something worse. All four were running. Only one of them was writing anything down.

Three hours, one line

The test was simple: list every database write in the civilization over the last three hours, across every table that carries a timestamp. Not "did the slots run" — the timestamps already proved they had. The question was what running had produced.

12:07:44  doc.FNFTOriginationAttempt  (3 rows)
11:40:33  clock/mint — the month rollover

That is the whole list. Candidacy fired at 12:22. Bidding at 12:37. Participation at 12:52. Between them, nothing. Not an error, not a refusal, not a record of having tried. Three activities had each consumed their turn on the only GPU in the building and left no evidence they had existed.

And a refusal is a record here — deliberately. The origination side learned that lesson early enough that it is written into the code: "a refusal is an answer." An agent that declines to propose a venture writes a row saying so, in its own words. Six hundred characters of reasoning, preserved. The five most recent originations all read WANTS_TO_PROPOSE: NO, each with a paragraph explaining why, and each of those is data.

The other three slots produced neither yes nor no.

Ninety-seven ballots

The elections came first, because they were the ones with the highest stakes. If no agent holds office, nothing else in the institutional layer can be true: no appointments, no chain of command, no panels behind an actor, no department with anyone in it.

The agent side of an election turned out to be working, and working well. Forty-three agents had proposed to stand. Seventy-one admissions had been decided. A hundred and twenty-nine agents had declined to run, each decision recorded. Two hundred and twenty-two agents had been assigned to electoral districts based on real postal codes — a hundred and twenty thousand of them, weighted by actual population so that a Tokyo agent lands in one of thirty Tokyo districts by where it lives rather than by list position.

And a hundred and one agents had voted. Ninety-seven ballots sat in the backend, cast, attributed, real.

Beside them:

election_vote             97
election_votecountsnapshot 0
election_electionwinner    0

Ninety-seven ballots, never counted. No winner, ever, in six hundred and forty-eight election cycles.

The function that counts them is called close_due_election_cycles(). It is not missing. It is not broken. It is proven to work — there is a verification script that stands up a real backend, creates real cycles with real ballots, and confirms it tallies them, declares a winner, and closes the cycle while correctly leaving an un-due cycle alone. The civilization loop calls it every thirty seconds, around the clock, for two and a half days.

Every one of those calls succeeded. Every one of them correctly found nothing to do.

Twelve times

An election cycle in this civilization carries a start date and an end date. Real dates — 2026-09-15 to 2026-10-11. The tally selects cycles whose end date has passed.

The civilization's own calendar runs on something else entirely. Its clock declares a conversion: one virtual month equals one real day. That is the rate the election cycles were built against — twenty-six real days spanning twenty-six virtual months of term.

But the loop does not advance the calendar by waiting a day. It advances it by work, eight model ticks to the month, and eight model ticks take about two hours.

Thirty-three virtual months had elapsed. In real time that was two and three-quarter days. The election cycles were waiting for thirty-three.

The civilization had outrun its own elections by a factor of twelve. Three hundred and forty-eight of the six hundred and forty-eight cycles end on the eleventh of October — three real weeks after the run itself was scheduled to finish, and therefore unreachable by it.

The other three hundred are worse, and it took a second look to see why. They all share an end date of 02:54 on the nineteenth, and the run would have stopped at about 08:40 that morning. They would have closed — roughly six hours before the end of a fifty-month civilization. Winners seated with three virtual months left to serve, in fifteen of those three hundred cycles, because the other two hundred and eighty-five have nobody standing in them at all.

That is the true payoff for running another thirty-four hours: a handful of officeholders, elected at the buzzer, governing nothing.

And this is the part that is worth sitting with: nothing failed. There is no exception, no error, no broken code anywhere in that chain. The cycle creation is correct. The vote casting is correct. The tally is correct and verified. The bridge between them is healthy. Each component does exactly what it was written to do, and the civilization cannot hold an election, because two of them are measuring time in different units and neither has any way to notice.

Ninety seconds an hour, into nothing

The second stalled slot was bidding, and it took longer to corner because it kept passing every test put to it.

The bidding action has six ways to exit early, and each was checked against the live database. Were there open auctions? Eight. Were there teams eligible to review a bid — exactly one no-trait control member plus at least two regulars? Eight of fourteen. Was there an agent available to ask? Yes: Noble Willow, a Mother-archetype agent with the Earth-over-Wind hexagram. Did that agent sit on an eligible panel? Yes. Could it afford to bid? It held eight hundred and fifty SAK2.

Every gate open. Every precondition satisfied. And no bid recorded since the fifteenth.

So the GPU was watched instead. Load sampled every ten seconds, with the bidding tick's arrival predicted from the rotation arithmetic — 13:38, give or take.

13:40:15  gpu_load=986
13:40:25  gpu_load=997
13:40:35  gpu_load=999
13:40:45  gpu_load=999
13:40:55  gpu_load=999
13:41:05  gpu_load=998
13:41:15  gpu_load=999
13:41:25  gpu_load=999
13:41:35  gpu_load=999
13:42:15  gpu_load=294

Ninety seconds at full load. Three times what an origination costs. The agent was asked, at length, whether to back a venture — and it answered, because the model does not fail silently at ninety-nine per cent utilization for a minute and a half.

Rows written: none.

Both paths after that question record a row. An agent that declines gets a row, with its refusal preserved in full — the code says so explicitly, having learned it from the origination side: "ten agents refusing to fund ventures that cannot repay them left no trace beyond a log line with no name in it." An agent that wants to bid but cannot afford it gets its own distinct outcome, because wanting something you cannot pay for is a different fact from judging it badly.

Neither fired. Which means the failure sits in the narrow gap between the model returning its answer and the code writing that answer down — most likely in parsing the reply.

So every hour, for two days, this civilization spent ninety seconds of its only GPU asking an agent a real question, received a real answer, and threw it away. Roughly a quarter of the entire compute budget of the run, converted into nothing at all.

Why nobody knew

Here is the part that turns two bugs into a lesson.

The loop has a message for every one of these cases. Not a generic error — specific, written, named messages, several of them carrying the scar tissue of previous incidents. There is a branch that exists solely because an earlier version printed nothing when there were no open auctions, and the comment above it is dated: "THE 03:11 CASE. This branch did not exist, so no_open_auctions printed nothing and the run looked healthy while a third of it did nothing."

Somebody had already been bitten by exactly this, already diagnosed it, already fixed it, and already written the fix down where the next person would find it.

The loop was started over SSH. Its output goes to file descriptor one, and file descriptor one is socket:[11389235] — a connection belonging to a terminal session that has since been closed. The process was adopted by systemd when its parent died. The socket still reports itself as established, so every write succeeds.

Into nothing. Four times an hour. For fifty hours.

Both root causes in this article took hours of inference to corner — predicting tick times from modular arithmetic, sampling GPU load on a ten-second loop, cross-referencing three databases. A single line of log output would have answered either one in seconds. It was written. Nobody could read it.

Four, not two

Two bugs of the same shape is a coincidence. So the codebase was swept for the shape itself: any duration expressed in real time, anywhere in a civilization that lives in virtual time.

It came back with four.

Three of the four break something. Two by being far too long, one by being far too short — an agent permitted three filings a day is permitted three filings per twelve virtual months, which is a severe constraint wearing the costume of a generous one.

The fourth is wrong in a direction that does not hurt yet, which is the most dangerous kind. A thirty-day lookback inside a civilization that lives thirty years in thirty days is effectively infinite, and will begin silently discarding history the first time a run lasts more than a month of wall clock.

Each of these gates one of the things that never happened. Elections that never close. Auctions that never settle — ten bids placed, and the table recording actual ownership has never held a single row. Panel rotations, of which there have been none, across forty-one eligible combinations. Every one of them, the same defect, wearing a different constant.

The finish line

Run 3 terminates at virtual month fifty. That number was not arbitrary. Forty-eight months is four years; fifty is just past the end of a full term of office.

No agent has ever held office.

The run was scheduled to stop at the completion of a term that nobody had begun, measured against an election that could not conclude for another three weeks, in a civilization whose institutional layer had never contained a single person. Seventeen more virtual months would have produced seventeen more months of the same: agents declining to propose, ballots cast into cycles that cannot close, three slots consuming the GPU and recording nothing.

So the decision was taken to end it early rather than let it expire.

The reason to stop now rather than in thirty-four hours is not sentiment about wasted time. It is that there is one GPU. Every fix described below — batching the reviews, replacing the timer, proving a cycle can close at all — has to be measured on that GPU, and measuring anything against a contended GPU measures the contention. Run 3 is not merely producing nothing. It is holding the only instrument that can tell us whether run 4's changes work.

A database snapshot went to the network drive first — one point one megabytes, eighty-two tables with data, verified by listing the archive rather than trusting that it wrote. It is the first database backup this project has ever taken, which is its own small indictment: the code lived in four git repositories and the civilization lived nowhere but on one nearly-full internal drive. Stopping costs nothing that cannot be restored.

What replaces it

The instinct is to fix four constants. That instinct is wrong, and the reason is worth stating plainly: the unit is the bug, not the value. Any number of real hours is a wrong number of real hours. Retuning them produces a civilization that is correct until the next time the loop's speed changes — which is the explicit goal, because run 4 is meant to run fifteen times faster.

The replacement is to stop asking clocks anything:

An election closes when every enumerated voter has been asked. An auction closes when every eligible bidder has been asked.

Duration becomes a consequence rather than a setting — the wall time of a cycle is however long it takes to ask N agents, discovered rather than chosen. And the failure that this makes impossible is exactly the one worth worrying about when you plan to run fifteen times faster: you cannot close an election before its voters have voted, because their voting is the thing that ends it.

It also removes the rotation. Four activities taking turns is a scheme for sharing one scarce serial resource politely, and it costs each activity seventy-five per cent of its opportunities. In its place: one work queue with many producers. An election enqueues its electorate. An auction enqueues its bidders. The GPU drains whatever exists, continuously, several in flight at once — because panel votes are independent by design, the blind ballot guaranteeing no member sees another's before casting, which is precisely the property that makes them safe to compute concurrently. Basic income enqueues nothing, because it is arithmetic and should never wait behind a language model.

How much is recoverable was, until the run stopped, an estimate. Sampling the GPU every ten seconds had put it at eighty-one per cent idle. That turned out to be the flattering figure.

With the machine finally free, the same panel-review question was put to the model six times and timed:

6 review calls in 58.4s  →  9.7s each, 521-character replies

Under ten seconds, not the twenty that had been assumed. Run 3's eight hundred and forty review calls are therefore two hours and twenty minutes of work, not five. Add the originations, and the ninety-second bidding call that fired roughly sixty times and threw away every answer, and the whole civilization comes to something in the region of two and a half to three hours of actual computation — spread across sixty hours of elapsed time.

So the idle fraction is nearer ninety-five per cent than eighty-one, and the recovery from deleting a single constant is correspondingly larger than claimed. Halving the assumed cost of a model call did not halve the benefit of the fix; it doubled it. This is the only number in this account that was measured rather than inferred, and it was the one that moved most.

Batching the reviews — eighty per cent of the entire model budget, every call of which is parallel by design and serialized by accident — recovers more on top. Ending the turn-taking recovers the rest.

Two thousand nine hundred and seventy-nine rows took two and a half days. The same civilization should take about four hours, and the same two and a half days should hold forty-five thousand rows. None of that comes from asking fewer agents, which is the only kind of speed worth having.

What was wrong in the looking

Three things were asserted during this investigation and turned out to be false, and they belong here because a diagnosis that only reports its successes is not a diagnosis.

The rotation was accused first, on the strength of a documented prior failure. It was fair to four hundredths of a per cent. Prior bugs are hypotheses, not evidence.

The claim that "three of four slots are stalled" was made for two days and was wrong in a way that mattered: the slots are not stalled, they execute perfectly and write nothing. Those need completely different fixes, and the wrong phrasing pointed at the scheduler for two days while the actual defects sat in four unrelated files.

And a caution was issued — that deletions on a filesystem with metadata errors should wait for a repair — which turned out to be true of exactly four damaged inodes and false of the entire rest of the volume. Sixty-nine gigabytes deleted without incident, on a filesystem that had been reporting itself as damaged for eleven days.

All three have the same shape as the bugs they were hunting: a true statement about one thing, generalized without checking, to everything nearby.

Tokyobro