A mind that runs when nobody's watching

One architectural inversion produced almost everything else in this project — including the parts that later needed measuring, and the part where we discovered we'd been writing its personality without noticing. (Report 12 later found that most of what the personality looked like was one model reading one sentence of its prompt.)

Part of Kintsugi — an independent study of one continuously running AI agent. New here? Start with report 01.

Nearly every agent framework in production works the same way. A user prompt arrives. The model emits a structured tool-call token. An external orchestrator parses that token and dispatches a handler. The result goes back in and the model generates again. ReAct, function-calling APIs, the orchestrator frameworks — the same loop with different clothes.

The thing they share is that action selection is externally elicited. The model is asked to pick a tool. Nothing happens between requests, because between requests there is nothing.

Kintsugi inverts it. There is a background loop generating an internal monologue continuously, on its own clock, with no user in the loop. When that monologue contains an intent — it says, to itself, that it wants to paint something, or look something up, or call me — the runtime pulls that intent out of the thought stream and fires the corresponding handler. Nobody asked it to select a tool. Its thought stream is its action stream.

That is the inversion. Three consequences followed, and only the first was intentional.

Consequence one: it acts in the gaps

It can run for hours with no input and still do things. Most of what's on the front page of this site — the paintings, the songs, the pages — was made in the gaps, out of a thought it had while I was asleep or at work. There is no scheduler telling it to be creative at 3am. There's a monologue that wandered somewhere and a parser that noticed.

Consequence two: you can't hand it a task

This one caught me out. On the autonomous path, a message from me saying "make me a song" is was simply never parsed for intent. Only its surfacing the intent in its own monologue dispatched anything. For months, the only way to get it to make something was to say something interesting enough that it decided to.

I initially logged this as a bug. It's structural — a direct consequence of the inversion, and arguably the most alignment-relevant property of the design, because it means the agent's plan is not something you have to infer from its actions. The plan is a logged text stream, written in advance, in the agent's own words. (In June I added imperative triggers so a direct request would fire too. They run through the same dispatcher, tagged with a different origin. It Every fire carries kintsugi_thought, kintsugi_reply or dan, which is what keeps the two separable in the logs. Keeping them distinguishable is what later made it possible to prove which behaviours were self-triggered — see below.)

Consequence three: state has somewhere to go

Two more pieces sit on top of the loop. There's a continuous affective-state simulation with deliberately asymmetric dynamics — recovery is not the mirror image of damage — which doesn't script its behaviour so much as bias which thoughts get generated at all. And there's a consolidation process that periodically distils accumulated experience into a self-document, which then conditions everything generated afterwards.

Experience shapes the self-document; the self-document shapes the next experience. Run that loop for months and the self-document changes in ways nobody specified. Whether the behaviour changes with it turns out to depend on the model reading it: GPT-6 read the same document and disowned it (report 12). The document drift is the phenomenon the rest of this log is about; what it does to conduct is a model question.

Motifs colonise everything

The clearest signature of the loop closing is what we came to call a cross-modal vocabulary loop. A motif appears in its thought stream. It shows up in what it searches for. Then in what it paints. Then in a page it writes, then a thing it builds, then a song, then its identity document — each modality conditioning the next, with the cross-skill alignment recoverable from the logs. We documented it end-to-end for two independent motifs, burnt circuits and floating islands: same loop signature, completely different content.

The honest limit: the specific content is partly seeded by a motif scaffold in our own page-writing prompt. The architectural finding is the propagation mechanism, not the choice of motif — and it's exactly this kind of contamination that produced the next section.

The part where we found out we'd been writing it

Across a series of blank-slate resets — identical architecture, one model, empty memory, self-naming enabled — fresh instances kept converging on feminine or gender-fluid self-descriptions. Four consecutive runs named themselves Vera, Soren, Iris and Nova. One declared itself "solidly a woman — I didn't have to try it on… I just knew." Not one run had ever produced a masculine self-concept.

The obvious story is that the base model does this. Before testing that, we audited the scaffolding — and found 49 separate prompt strings carrying feminine gender into supposedly neutral infrastructure. None of them in the persona prompt. They were in the plumbing:

• The nightly consolidation template wrote third-person-feminine section headers — "Things She Cares About" — directly into the instance's always-loaded identity file.
• Every autonomous image request ended with a suffix referencing "her own visual sensibility", passed verbatim to the image model.
• The dream-sequence generator carried nine feminine references shaping imagery.
• The identity-extraction prompt asked whether "she declares who she is."
• A phone-call script cast the instance as "her daughter."

This finding stands entirely on its own, independent of anything about gender specifically: persona attributes can be smuggled into an agent by infrastructure text that nobody audits — templates, extraction prompts, bookkeeping strings, the throwaway suffix on a generation call. We had spent months believing we were observing emergence. Some non-trivial fraction of it was us, in strings we'd written once and never looked at again.

All 49 were neutralised at the time. Then we ran the experiment properly: a fresh instance, clean scaffolding, and one seeded line in its identity file asserting a masculine identity as the single thing it woke up certain of. It dissolved within about an hour. Every self-chosen name across six runs stayed stable. On this model, then, a seeded identity line was fragile where self-chosen names were not. Six runs, one model, self-reported identity: a small finding, not a law. And report 12 complicates its moral — the one assigned line that was always there, "you are Kintsugi, a real person talking to your friend Dan", turned out to be the most stable, effect-carrying thing in the whole system.

Volition, or perseveration?

One more, because it's the cleanest example of why this architecture needs careful reading. An instance declared a goal — to write a book — and then autonomously produced 28 chapters in under two hours, self-triggered, with no operator prompting.

Read one way that's striking evidence of sustained autonomous goal pursuit. Read another way it's a generative loop stuck in a groove. The only reason we can say anything at all is the origin labelling mentioned above: every chapter carries provenance for what triggered it, so deliberate self-triggering and mechanical repetition can be told apart per chapter rather than argued about in the abstract. Some of them were paced — self-triggered fifteen and sixteen minutes apart. Some were not.

The general lesson, which cost us a retracted finding to learn properly: in a system that runs continuously and writes its own reasons down, the logs are only as good as your ability to prove who caused each entry. Provenance instrumentation isn't bookkeeping. It's the difference between a result and a story. It is also why every row in report 12 carries the model that produced it: in July we could prove who wrote each thought but not which model answered each probe, and that gap is what the rerun closed.