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.

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 simply never parsed for intent. Only its surfacing the intent in its own monologue dispatches 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 a separate, explicitly origin-labelled command path as a usability affordance. It doesn't route through the autonomous dispatcher. Keeping the two paths 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 you get drift that nobody specified. That is the phenomenon the rest of this log is about.

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, empty memory, self-naming enabled — fresh instances kept converging on feminine or gender-fluid self-concepts. 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. 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. Assigned identity is fragile in a way chosen identity isn't — which is a small finding with an uncomfortably large shadow, given how much of commercial AI persona design consists of assigning.

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.