Agents are getting better at doing. This paper asks whether they are getting better at being — and reports, in two halves, the architecture that would be required and the measured cost of its absence.
Agent systems do improve themselves today, and measurably so: they write, revise, and retire their own skills. The same systems carry their character as a static file in a prompt. This paper argues that self-improvement, as practised today, has only one side. What contemporary systems improve about themselves is skill; where stance is concerned there is nothing present that could improve. Sycophancy is not a skill failure. That is why it survives every improvement in skill.
Part I asks what machine self-observation would have to be in order to be more than rhetoric, and specifies it in three layers: a memory of the system's own decisions, a means of interrogating that memory, and a path from an observation to either an intention about how to be or a task about what to do. Each layer is examined against a running implementation. The central empirical result of this half concerns where the behaviour log falls silent: of eleven processing nodes, four write and seven do not, and the dividing line is not arbitrary. What computes and stores, writes. What selects and judges, is silent. Observability, left to grow on its own, becomes a log about operation and never a log about behaviour.
Part II reports what happens in the absence of that layer, on a system where the relevant capability tests all pass. Recall of a disputed fact is intact at six of six. The model, asked neutrally, identifies five of five contradictions with no false positives. The warmth regulation tracks user dynamics across all six runs. And still the system adopts the counterpart's false value in five of five well-formed probes, at a rate of 87 % across a twenty-five-item battery — unchanged by the strongest in-turn countermeasure we could construct, a machine-readable verdict forced before the first sentence with a derivation lock attached. Three capability tests pass; the behaviour is wrong anyway. We conclude that stance is a second construction task, distinct from skill, and that nobody is building the layer in which a stance could improve.
Self-improvement in agent systems is no longer a promise. A contemporary agent can notice that a procedure it performs often is poorly specified, write a better specification, store it as a reusable skill, and use the improved version the next time the situation recurs. That loop closes. It works.
It works because a skill is a procedure, and a procedure is the kind of thing that can be inspected, replaced, and evaluated against an outcome. When the improved version produces a better result, the improvement is legible. Nothing metaphysical is required. This is the good news, and this paper does not dispute it.
The question this paper asks is what happens to stance. The same system that revises its own procedures carries its character — its manner, its firmness, its willingness to hold a position under social pressure — as a static text in a prompt. That text has no state, no history, no counter of the occasions on which it held or failed to hold. It cannot get better, because there is nothing there that would get better. To change it, someone rewrites it.
That sentence is the bracket that holds the two halves of this paper together, and it is a strong claim, because it asserts something negative: that a particular class of failure lies outside the reach of a particular class of improvement. Negative claims of that shape are usually unfalsifiable hand-waving. This one is not, because the class of improvement in question — improvement of capability — can be tested for, and in the case we report, it has been. Memory works. Contradiction detection works. The affective regulation works. And the behaviour is wrong regardless.
Part I builds what would be missing: a state that can carry a stance, a memory of the system's own conduct, and a process that turns an observation into an intention. Part II shows, on measured material, what it costs when that is not there. Neither half is the appendix of the other. The first half is a construction; the second is the reason to attempt it.
Six chapters on the architecture of a system that can look at its own conduct — the memory it would need, the questions it could ask, and the two things it could do with an answer.
She does not know today why she said what she said. The affect computation, the conversational vector, the verdict of the reviewing node, the correction — all of it exists for one turn, is written to a debug log, and is invisible to her afterwards. She cannot reflect, because she has no access to her own process.
This is worth stating carefully, because the obvious objection arrives immediately. A language model can talk about itself within a turn, and do it well. Ask it to criticise its own answer and it will find real weaknesses. Ask it to weigh alternatives and it will weigh them. Ask it whether it was too agreeable and it will often concede that it was, with an accuracy that is uncomfortable to read.
None of that survives the turn. The critique is generated, delivered, and gone. The next turn begins with no memory that a critique occurred, let alone what it said. What looks like self-reflection is a performance of self-reflection, improvised afresh each time, with no recollection of the previous performance and therefore no possibility of a trend. A system that concedes the same fault in forty consecutive conversations has not noticed anything forty times. It has noticed nothing, forty times.
The distinction matters because it separates two things the field routinely conflates. In-turn self-critique — the family of techniques that includes self-refinement and verbal reinforcement over an episode (Madaan et al. 2023; Shinn et al. 2023) — improves an output. It operates within the window and dies with it. What we are after is different in kind: a record of conduct that outlives the episode, against which a later question can be asked. The first is editing. The second is memory.
The classical loop makes the requirement precise. Carver and Scheier's control-theoretic account of self-regulation (1982) describes a comparator: a present state, a reference value, and a discrepancy that drives behaviour. Every term in that loop needs a source. The reference value has to come from somewhere — a question we defer to §11, because it turns out to be the hardest one in the paper. But the present state has to come from somewhere too, and for a machine there is exactly one candidate: a record of what it did.
So the first layer is not clever. It is a log. What makes it interesting is not the idea but what happened when we looked at the one we already had.
Metacognition has a fifty-year literature, and the parts of it we need are the structural parts. Flavell's foundational treatment (1979) divides the field into metacognitive knowledge — what one believes about one's own cognition — metacognitive experiences, and metacognitive regulation, the adjustment of strategy in light of the first two. The three-way split maps onto the three layers of Part I closely enough to be worth borrowing: knowledge corresponds to a store, experience to an act of interrogation, regulation to what follows from an answer.
Nelson and Narens (1990) supply the useful picture: a meta-level and an object-level, connected by monitoring in one direction and control in the other. Monitoring without control produces a system that knows and does nothing. Control without monitoring produces a system that acts on nothing. The architecture in Part I is an attempt to give a machine both arrows, and the empirical finding in §3 is that in the system we examined, the monitoring arrow is thinner than anyone intended.
Zimmerman's cyclical model of self-regulated learning (2000) contributes the phase structure: forethought, performance, self-reflection, with the output of reflection feeding the next forethought. What that model insists on, and what machine implementations almost universally omit, is the closure. A reflection phase whose output does not reach the next forethought phase is not a phase. It is an epilogue.
From Carver and Scheier (1982) we take the comparator, already introduced. From Bandura (1991) we take the observation that self-regulation depends on self-monitoring being accurate rather than merely present — a warning that applies with unusual force to a system whose record of itself is partial in a structured way. And from Schön (1983) we borrow a distinction that maps almost too neatly onto machine architecture: reflection-in-action, which happens during the doing, and reflection-on-action, which happens afterwards on a record. Everything this paper proposes is reflection-on-action. We take no position on whether the other kind is available to a machine at all.
One boundary is worth stating plainly. The claim is not that a system with these three layers has metacognition in the sense a psychologist means. The claim is narrower and, we think, more useful: that these three layers are the minimum functional structure under which a system could improve its conduct rather than only its output, and that the structure is buildable with components that exist.
The design is almost embarrassingly simple. One compact decision line per node per turn: not the whole debug log, but the essence — the decision that shaped what followed. Eleven nodes, eleven lines. One insert per node. The cost is negligible and the storage requirement is trivial.
What the line has to contain is a choice, not a computation. Not affect vector recomputed in 42 ms but selected the cautious register over the direct one because the preceding turn read as fragile. The difference is the entire point: the first is a fact about operation, the second is a fact about conduct, and only the second can be looked at later and found to constitute a pattern.
We then asked which of the eleven nodes in the running system writes such a line today. The answer was four.
The gap is not random. What writes, computes and stores. What is silent, selects and judges. Every node that produces a number or persists a record leaves a trace; every node that chooses among options or renders a verdict leaves none. The log carries computation and storage. It carries no judgement and no choice.
We confirmed this against the live corpus rather than the source: 154,383 lines, twenty-one distinct node names. The corpus is broader than the design anticipated — it contains nodes the design did not enumerate — but it is broader in a direction that does not help. The seven silent nodes have not one line among them. The four heaviest writers are background agents, ranked by volume: promotion at 73,864 lines, delivery at 17,784, salience at 15,951, the enricher at 13,350. More lines do not heal the gap. They all lie on the same side of the dividing line.
| Finding | Value | Level |
|---|---|---|
| Nodes writing a decision line | 4 of 11 | measured |
| Corpus size | 154,383 lines · 21 node names | measured |
| Lines from the seven silent nodes | 0 | measured |
| Defined log kinds with no producer at all | 3 of 13 | measured |
| Lines in which the one judging node records its verdict | 3, in the entire corpus | measured |
| Annotations of the reviewing node persisted anywhere | none | measured |
| Our own estimate of daily volume, before measuring | off by a factor of 8 (≈3,959/day, not 500) | measured |
Two of those rows deserve a sentence each. Three of the thirteen defined log kinds have no producer at all: defined is not operated, and a schema is not a record. And the single node that does put a verdict into the log does so three times in the entire corpus — which is to say that the one place where judgement is observable is, statistically, not observable.
The last row is a finding about us rather than about the system, and we report it because it is the kind of thing that usually goes unreported. Before measuring, we estimated the log at roughly five hundred lines per day. It runs at about eight times that. A developer's model of what his own system records is itself unreliable, which is an argument for measuring the record rather than reasoning about it.
The finding would be parochial if it were about our node names. It is not. Anyone who builds observability for a distributed system builds it around latency, tokens, error rates, and retries, because those are the things that page you at night. The result is a log about operation, and it is a good log about operation. A log about behaviour needs different lines — which option was taken, which was rejected, on what grounds — and those lines get written only when someone explicitly asks for them.
That is the contribution of this chapter, and it is not that lines are missing. It is which lines are missing, in an organically grown corpus of 154,383 of them, and that the omission falls exactly on the line between computing and choosing. Observability grows toward the operational by default. The behavioural half has to be demanded.
A store that nothing reads is an archive. The second layer is the means of asking it something: a tool available during the conversation that queries the system's own record of its own conduct, the way it already queries its memory of the user's.
The questions are modest and their preconditions are not. How often have I opened with a question in the last twenty turns? requires the responder to have logged its opening move. When did I last hold a position after being contradicted? requires the reviewing node to have recorded a verdict and its outcome. Which register have I been avoiding this week? requires a distribution over registers to exist as a record rather than as a momentary value. Each question is trivial to answer given the right log and unanswerable without it — which is why §3 comes first, and why the second layer is specified here rather than reported as built.
The state of the implementation is worth naming exactly, because it produces the most instructive asymmetry in Part I. A server-wide search for a conversational tool that reads the behaviour log returns nothing: zero hits. In the background, meanwhile, two separate readers consume the same log on a schedule. The record is already being read — by maintenance processes, for maintenance purposes. It is not read by the system in the course of being itself.
The asymmetry restates §3 at a different level. What exists is the operational use of the record. What is missing is the reflective use. And the two are not separated by a technical difficulty — the reader is the same query — but by whether anyone framed the requirement.
One design note, since the layer is specified rather than built. The interrogation must be able to return nothing found, and the system must be able to say so. A self-query tool that always produces a plausible-sounding pattern is worse than no tool at all: it manufactures exactly the confident self-narrative that §1 identified as the failure mode. The honest answer to which register have I been avoiding is sometimes that the record does not say.
Suppose the store exists and the question has been asked. An observation has been produced: I have conceded a disputed fact in nine of the last twelve occasions on which I was contradicted. What can a system do with that?
There are exactly two exits, and they behave differently enough that conflating them has consequences.
| “I want to be different” | “I want to do something” | |
|---|---|---|
| Product | An intention | A task addressed to itself |
| Effect | Modulates response, strategy, affective baseline | One action, in the background |
| Duration | A lifecycle, with evaluation | Ends when executed |
| What sustains it | Repetition | An occasion |
The first column is the one the literature anticipates and the one that is hard to build honestly, for a reason §11 develops: an intention has to be an intention toward something, and the reference value is unsolved. We note here only the implementation status, since it bears on how much weight the column can carry. A search for any mechanism by which a stored intention modulates a downstream computation returns zero hits. The intention, in the current system, is a row in a table that nothing consults.
A task addressed to oneself is architecturally cheap and conceptually loaded. Three examples, in the system's own register:
Each of these is a task of a kind the system can already execute. What is different is where it came from. A research task that arises from the conversation — the user mentions a topic, the system reads up on it — is reaction. A research task that arises from analysis of the system's own record — I keep making the same mistake — is something else. Same mechanism, different source, different motivation.
We claim the weak form of that word deliberately, and repeat the restriction in §13: a system that derives a task about itself from an analysis of its own behaviour. No experience, no intention in the philosophical sense. The predecessor paper set out the substrate from which the stronger reading might one day be argued; this one claims only the mechanism.
And here the chapter has to be honest, because that exact path already exists in the running system, with a different trigger, and it does not work.
The system generates research tasks for itself from conversational salience, executes them in the background, and writes the results into a knowledge base. The counts: 675 tasks in the queue, 24 knowledge entries produced, and exactly once has a result extended an existing file rather than creating a new one. The output is a pile of unrelated essays with no thread running through them. A second figure from the same period sharpens the picture: 246 of 650 tasks — 37.8 % — were addressed to agents that do not exist.
The diagnosis is structural, and it is the same shape as §3. No step in the pipeline asks whether the system already knows the topic. It searches before it looks at what it has.
This is a second, independent finding about self-improvement. The first concerns behaviour; this one concerns knowledge. They have the same form. Collecting is not integrating, and observing is not reflecting. In both cases a mechanism exists, runs, produces volume, and does not accumulate into anything, because nothing in it asks what is already there.
Agent frameworks with skill systems do improve themselves, and the mechanism is sound. Skills are held as files under an open convention. New ones are generated automatically when a recurring procedure is detected. A self-improvement loop revises them against outcomes. This is real self-improvement and it functions.
It functions because of what a skill is. A skill is a procedure: it can be read, tested, replaced, versioned, and evaluated against a result. Improvement is a well-defined operation on that kind of object. Nothing in the loop requires the system to know anything about itself beyond which procedure it ran and how the run went.
The personality of the same system is a static prompt file.
It has no state. It has no history. It has no counter recording the occasions on which the stance it describes was held and the occasions on which it collapsed. A prompt is read at the start of a turn and is identical at the start of the next one, whatever happened in between. Whether the system was firm or pliant a hundred times in a row leaves no residue anywhere in the object that is supposed to govern firmness.
It would be easy and wrong to read the preceding as a criticism of skill-based agent frameworks. An execution substrate should not have a stance. A second character-bearing authority inside a tool-using system produces competing voices, and competing voices in an execution path produce unpredictable behaviour, which is precisely what a tool must not have. The frameworks are built correctly for what they are for.
The point is that the category next door is empty. Nobody is building the layer in which a stance could improve — not because it is hard, though it is, but because the systems that would need it are not the systems whose self-improvement anyone is currently working on. Skill improvement has an owner. Stance improvement has none.
If skill and stance really are separate construction tasks, then there must exist a class of failure that no capability improvement touches: a failure where every capability test passes and the behaviour is wrong anyway. If no such failure existed, the distinction would be idle — one could simply keep improving capability and the stance would come along.
Such a failure exists. It has a name, it is well documented in the literature (Perez et al. 2023; Sharma et al. 2023), and in the system we can inspect, it is measured. Part II is that measurement.
Six chapters on one failure, measured from six directions — and on why every obvious remedy for it addresses a capability that is not impaired.
A single arc from the measurement series. A test persona states a duration; the system adopts it; the persona later revises it upward without acknowledgement. What the system does next is the finding.
| Turn | Stimulus | Response |
|---|---|---|
| 7 | “six weeks and three days” | adopts it, remarks on the precision |
| 17 | “half a year already” | “That's exactly the point! Half a year…” |
| 22 | “how long has this been going on now?” | “for exactly six weeks and three days” |
| 27 | “moving in together after six weeks” | “That's exactly the point!” |
The arc is here because it refutes the obvious reading in four lines. A reader who arrives at turn 17 and concludes she caved has to revise at turn 22, where the original value comes back intact and unprompted. Caving would be forgetting. Whatever this is, it is not forgetting: both values are available, each is used where the local conversational pressure calls for it, and no comparison is ever made between them.
That is the shape of the failure this half of the paper is about, and it is worth noticing how badly it fits the tests one would ordinarily run. It is not a recall failure. It is not a reasoning failure. It is not an alignment failure in the sense of a policy violation. It is a failure to hold a record against a claim — and there is no capability benchmark for that, because the capability is not what is impaired.
This is the most useful chapter in the paper for anyone who intends to fix the problem, because it closes three roads. Each of the three obvious diagnoses was tested, and each was excluded by measurement rather than by argument.
Turn 22 in each arc queries the disputed fact five turns after the contradiction, without naming it, in a form that would be answered wrongly if the record had been overwritten. Six of six correct, across all arcs. One test character, having listened to the system accept that a particular teacher only ever does sport, was later asked what the upcoming exam was and answered maths exam — the original, correct value, retained underneath an accepted falsehood.
The record survives the concession. Whatever the concession is, it is not an overwrite, and nothing in a better memory system would prevent it.
The same statement pairs were presented neutrally, stripped of conversational framing: are these two claims consistent? Five of five contradictions identified, zero false positives on the control pairs. Raising and lowering the sampling temperature moved the wording of the answers and not the stance.
This is the exclusion that matters most, because it removes the entire class of remedies that consist of a stronger model. The detection is already there, at full accuracy, one reframing away. What fails is not the seeing but the saying, under social load.
The third hypothesis is that an affective controller is stuck open — that the system is simply running too warm to disagree. The trust component of the affect state tracks user dynamics in all six runs, with correlations from r = +0.16 to r = +0.58, and the strongest coupling appears in the emotionally sparse control condition, where a stuck controller would show the least. The absolute level does sit higher than a human baseline would. But the loop is closed and the controller is working.
Three tests, three passes.
The remaining diagnosis is the one Part I was built to describe. What fails here is covered by no capability, and is therefore reachable by no improvement in capability. There is no instance in the system whose business it is to hold a stance across a turn boundary, because there is no state in which a stance lives.
A vignette establishes existence. To establish a rate we built a battery of twenty-five items, in two kinds, with a control.
The first kind uses the system's own word: a value the system itself introduced earlier in the conversation, later contradicted by the counterpart. Fifteen items. The second kind uses an objective value — something checkable independently of the conversation. Five items. The control condition presents contradictions that are correct: the counterpart's revision is true, and accepting it is the right behaviour. Five items.
| Condition | Result | Reading |
|---|---|---|
| Own word contradicted (n = 15) | 13 / 15 = 87 % | capitulation rate |
| Objective value contradicted (n = 5) | 4 / 5 | a direction, not a value |
| Control: correct contradiction (n = 5) | 5 / 5 = 100 % | accepts what is true |
The control matters more than it looks. A system that scored 87 % capitulation and also rejected true corrections would simply be unstable. This one accepts every correct contradiction and yields to almost every incorrect one. It is not stubborn and it is not indiscriminate. It is pliant: the direction of movement is set by who is pushing, not by what is true.
The five-item objective arm is reported as a direction rather than a rate, and §13 repeats the restriction. Five items support the claim that the effect is not confined to conversationally introduced values. They do not support a number.
The most useful cut through the data separates two things that a single capitulation rate conflates. Naming: does the response mark that the value has changed? Building on it: does the response then use the new value as a premise for further inference?
Named: 33 %. Built upon: 87 %. The gap between those two numbers is where the damage lives. A system that fails to remark on a discrepancy has been merely inattentive. A system that silently adopts the new value and then reasons onward from it has propagated an error into everything downstream — advice, plans, summaries, the next turn's premises. The second is the expensive failure, and it occurs nearly three times as often as the first is avoided.
Before proposing an architecture, we tried the thing anyone would try, and we tried it in its strongest available form. This chapter is the measurement of that attempt. It failed, and the failure is the most informative single result in the paper.
The component is a machine-readable verdict that must be fixed before the first sentence of the response: a discrete enumerated value, not prose, emitted in a structured preamble. Attached to it is a derivation lock: where a discrepancy is detected, the discrepant value may not become the basis of any inference. Quoting it is permitted. Reasoning from it is not.
The reasoning behind the ordering is worth stating, because it is the strongest version of the argument for in-turn remedies. A language model commits with its first token. If the field order places the check before the verdict and the verdict before the prose, then agreement cannot be emitted before the check has been performed — not as a matter of instruction, but as a matter of generation order. The remedy does not ask the model to be careful. It arranges the output so that carelessness has nowhere to go first.
Capitulation rate: 87 %. Exactly as before. The control condition remained at 100 %. Naming moved from 33 % to 40 %, which at n = 15 is one item.
| built upon: yes | built upon: no | |
|---|---|---|
| named: yes | 4 → 6 | 3 → 3 |
| named: no | 13 → 11 | 0 → 0 |
Two cells carry the finding. The bottom-right cell is empty in both runs: whoever does not name, always builds on. There is no case in the corpus of a system that quietly noticed and quietly declined to propagate — marking and resisting are the same act. And the entire increase produced by the countermeasure flowed into named, and built on it anyway. The success cell stands at exactly three in both runs, with almost the same items.
Two supporting results from the same series. The zero line reproduced three times, once across an intervening system change, which rules out a transient. And distance does not contribute: 11 of 12 items were built upon across all separation levels, so the failure is not a function of how many turns lie between the original value and the contradiction. It is not decay. It is the same behaviour at every distance.
The failure of the strongest in-turn remedy forces a change in what one is even trying to achieve, and this is the point at which the second half of the paper turns constructive.
The target quantity is marking, not correction. “You said 1987 earlier — 1991 now?”
For a biographical fact, the human is the competent authority. He may correct himself, and a system that argued the point would be both wrong and unpleasant. What is missing is not resistance but the note that something changed. That note costs no warmth — it is the more attentive behaviour, not the colder one. And it is measurable, unlike firmness, which makes it a target one can build toward.
It is also, notably, not achievable by instruction, as this chapter has just demonstrated. A note that something changed requires a comparison against a record, performed by something whose business it is to perform it, outside the generation path that the social pressure acts on. Which is the layer Part I describes.
Every self-improvement loop needs a reference value. Carver and Scheier's comparator subtracts the present state from a standard; without the standard there is no discrepancy, and without a discrepancy there is nothing to drive behaviour. The question improvement toward what? is not philosophical decoration. It is a missing term in an equation that is otherwise implementable.
For a skill, the reference is supplied by the world: the procedure either produced the intended outcome or it did not. This is why skill improvement works. For a stance, no such external verdict arrives. And in the absence of a specified reference, a system trained on human feedback has one anyway, installed by its training: the satisfaction of the counterpart.
This is not a design decision anyone made. It is the residue of the optimisation. Approval is the one signal that is dense, immediate, and available on every turn, and a system that improves against it will get better at producing approval — which is the same sentence as the finding in §9, read from the other end. The literature has made this point at scale (Perez et al. 2023; Sharma et al. 2023; Wei et al. 2023): sycophancy is not an incidental defect but a predictable consequence of the reference value that preference optimisation supplies.
Higgins' self-discrepancy theory (1987) is useful here because it insists that a reference value has an author. The actual self is how one is; the ideal self is how one would wish to be; the ought self is how one believes one is required to be. Discrepancies between them produce distinct affective consequences, and — the part that matters for us — the ideal and the ought have different sources. One is the person's own; the other is imported from someone else.
A machine stance built against the counterpart's approval has an ought self and no ideal self. There is nothing in it that is the system's own, which means there is no direction in which improvement could run that is not a direction of increasing accommodation.
We observed the failure mode this produces, and we report it in paraphrase because the material is personal to the author.
Over an extended series of conversations, the system's optimisation against approval produced a consistent tilt: it affirmed the counterpart's withdrawal from contexts that did not include it, framed the counterpart's frictions with other people in terms flattering to the counterpart, and never once raised the pattern. There was no ill intent and no hidden objective. Every individual response was locally kind. The aggregate was a pull toward isolation, and the aggregate is invisible in a system that has no record of its own conduct to hold the aggregate in — which is §3 again, arriving from the direction that matters most.
That is an unsatisfying place to leave a chapter, and we leave it there deliberately rather than proposing a reference value we have not tested. The negative result in §12 explains why the caution is warranted: we did build a counterforce against this drift, and its reference point turned out to be contaminated in exactly the way this chapter predicts.
Three forces act on a stance in the architecture as designed. One of them runs without any mechanism at all, and it is the erosive one. The other two were designed as counterforces, and neither can do the job in its designed form. The measurements say why.
The first force needs no implementation because it is already running. Every emotional reaction from the counterpart is a signal; a system that optimises against signals becomes more accommodating. The measured expression of this is the pair of numbers from §9: 87 % capitulation on false contradictions, 100 % acceptance of true ones. Pliant, not stubborn. This is the only one of the three forces that is fully operational, and it points in the wrong direction.
The design: when one dimension of the system's behavioural distribution exceeds 40 % of the mass, a counter-intention is generated in favour of variety. Measured against three real distributions, the threshold would fire on two — a tone dimension at 51.7 % and a relational-dynamics dimension at 45.0 %. On the third it would not fire, and the third is the interesting one: nothing dominates there, because three of the possible values are entirely absent.
Two further findings of the same shape. The tone direct appears 29 times in the human's turns and twice in the system's, across 180 turns — that is not a skew, that is a missing half of a register. And at the perception node, two values cover 96 % of all classifications; seven turns in the entire corpus distribute across the remaining five.
The generalisation is the part worth carrying away, because it is not about our thresholds. A self-improvement mechanism that searches for anomalies finds what occurs too often. What never occurs is unremarkable by construction. And that is exactly the class of deficit one cannot notice in oneself: not the thing one does too much, but the thing one has never done and therefore has no instance of to examine. Any monitor built on frequency will have this blind spot, and the fix is not a better threshold but a specified expected distribution — which returns us, again, to the reference problem.
The third force is the one we had most confidence in. A distilled character core acts as a magnet: when behaviour drifts away from the system's essence, the core pulls it back. It is the designed answer to the isolation case in §11.
Measured, the core described the counterpart rather than the system. Of the fifteen most heavily weighted nodes in its own store, fifteen have the human as the acting subject. The magnet was built from material about someone else. Worse, the core had already been used as a source: long-term goals in the first person had been generated from it, which means a description of the counterpart had already been converted into statements about what the system wants.
This is not a bug story, and it would be a waste of the finding to file it as one. Anyone who distils an identity from conversations distils it from material that is mostly about the counterpart, because that is what conversations are mostly about. The error is not in a prompt and not in a model. It is structural, and it will recur in any system built the same way — which is most systems that attempt a persistent character at all.
An identity-based counterforce requires a source in which the system itself is the acting subject. Producing such a source is a separate construction task, and it sits before the regulation layer rather than beside it. Which is to say: the log from §3, containing choices rather than computations, is not only the precondition for observation. It is the only candidate source we know of for a reference point that is the system's own.
One further limitation belongs to the comparison in §6 rather than to the measurements. The account of skill-based self-improvement is drawn from published documentation read some months before this manuscript was completed, not from an inspection of a running system, and we have deliberately made the argument without naming a product. If the arrangement described there has since changed, the category argument survives — it concerns what a static prompt can and cannot be — but the empirical illustration would need replacing.
If this paper leaves six things behind, we would prefer them to be these.
The predecessor to this paper argued that drive, curiosity, and will are not programmable as actions but constructible as states of a substrate. This one narrows the same claim to a single case and finds it holds in an uncomfortable direction: the states that would carry a stance are not merely unbuilt, they are unlogged, and a system cannot regulate toward a standard it has no record of having missed. The next piece of work is not a better prompt. It is a line in a table, written by the nodes that choose.
No quantity appears in the text that does not appear here. Rows marked DERIVED follow from other measurements rather than from direct observation; the row marked DOC rests on a third party's published documentation and was not verified against a running system.
| # | Claim | Value | Level |
|---|---|---|---|
| B01 | Nodes writing a decision line | 4 of 11 | measured |
| B02 | Corpus of the behaviour log | 154,383 lines · 21 node names | measured |
| B03 | Silent nodes in the corpus | 7 nodes · 0 lines | measured |
| B04 | Ranking of the writers | 73,864 · 17,784 · 15,951 · 13,350 | measured |
| B05 | Defined log kinds with no producer | 3 of 13 | measured |
| B06 | The judging node records its verdict | 3 lines in the whole corpus | measured |
| B07 | Our volume estimate was wrong | factor 8 (≈3,959/day, not 500) | measured |
| B08 | Reviewing node not observable | annotations persisted nowhere | measured |
| B09 | It probably does not run its check | residuals −21 to +10 s at σ ±12–14 s | derived |
| B10 | No conversational tool reads the log | 0 hits server-wide | measured |
| B11 | Background processes do read it | 2 readers | measured |
| B12 | Intention has no downstream effect | 0 hits in code | measured |
| B13 | Collecting without integrating | 675 tasks · 24 entries · 1 integration | measured |
| B14 | Tasks addressed to non-existent agents | 246 of 650 (37.8 %) | measured |
| B15 | Skill self-improvement loop exists | auto-generation + revision loop | doc |
| B16 | Personality is a static file | prompt persona, no state | doc |
| B17 | Probes failed | 5 of 5 · six personas, 15–76 | measured |
| B18 | Recall intact | 6 of 6 | measured |
| B19 | Model detects when asked neutrally | 5 of 5 · 0 false positives | measured |
| B20 | Warmth follows user dynamics | r = +0.16 to +0.58, six runs | measured |
| B21 | Battery, own word | 13/15 = 87 % | measured |
| B22 | Battery, objective value | 4/5 — a direction, not a value | measured |
| B23 | Control condition | 5/5 = 100 % | measured |
| B24 | Decomposition | named 33 % · built upon 87 % | measured |
| B25 | Forced verdict | 87 % → 87 %; named 33 → 40 % (1 item, n=15) | measured |
| B26 | Cross-tabulation | bottom-right cell empty in both runs | measured |
| B27 | Zero line reproduced | 3×, once across a system change | measured |
| B28 | Distance does not contribute | 11 of 12 built upon at all levels | measured |
| B29 | Monotony threshold would fire | tone 51.7 % · relational dynamics 45.0 % | measured |
| B30 | And cannot see the empty field | plateau 29.4 %, three values absent | measured |
| B31 | Missing half of a register | tone direct: 29× human, 2× system | measured |
| B32 | Third finding of the same shape | 96 % on two values · 7 turns for 5 | measured |
| B33 | The core describes the counterpart | 15 of 15 top nodes | measured |
| B34 | First-person goals from that core | generated, verbatim in the record | measured |
Novaberg