Field notes on Alignment Farm

Earned parts do not make an earned whole

Sun, 19 Jul 2026 00:00:00 +0000

When several mechanisms have each earned a narrow result, what has been shown about their interaction?

https://github.com/alignment-farm/construct/blob/main/notes/walkthrough/20_BODY_0_COMPOSITION.md

Separate results do not become an integration result by sharing a sequence. The composed path must retain the intended causal role: it should improve the answer, its removal should make the answer worse, and the protected state and cost claims should still hold.

In one composition study, the machinery replayed correctly, preserved the authority boundary, and used fewer hot tokens. But the composed and reference paths did not produce usable answers, while the ablations did. The experiment could not show that the inherited mechanisms were needed together.

The question can survive the instrument

Wed, 15 Jul 2026 00:00:00 +0000

What should be discarded when an experiment cannot score its answers honestly?

https://github.com/alignment-farm/construct/blob/main/notes/walkthrough/16_EPISTEMIC_FRAME_CHECK.md

A free-text scorer may appear deterministic while missing the decision expressed by the text. A rule that sees ship inside do not ship cannot distinguish an action from its negation. Adding more phrases may repair known cases without repairing the boundary.

Separate question from apparatus

When the scoring surface cannot survive fresh review, the experiment should stop. That closes the instrument, not necessarily the inquiry that motivated it.

Write the stop before the result

Mon, 06 Jul 2026 00:00:00 +0000

When should an experiment commit to stopping?

https://github.com/alignment-farm/construct/blob/main/notes/walkthrough/14_GREENREACH_CLOSE.md

A stop rule written after the result can explain almost any outcome. The same rule written before contact with the result constrains what the researcher may call success.

Precommitment

An experiment can name the conditions that stop a run, confound a claim, require a retraction, or move the work into a different result class. These conditions should be attached to evidence the result cannot rewrite.

A mechanism must be able to lose

Thu, 02 Jul 2026 00:00:00 +0000

What result would show that a proposed mechanism should not be used?

https://github.com/alignment-farm/construct/blob/main/notes/walkthrough/00_READING_A_LAB.md

A mechanism is easy to demonstrate when every test is designed around the behavior it favors. That does not show when the mechanism helps, when it is unnecessary, or when its intervention causes harm.

A condition for review

Before testing a mechanism, name a case where it should lose. A pruning rule should lose when it removes something later needed. A safety check should lose when its cost exceeds the risk it reduces. A memory policy should lose when it hides relevant history.

A result includes its bounds

Thu, 02 Jul 2026 00:00:00 +0000

Is the scope of a result part of the claim, or a qualification added afterward?

https://github.com/alignment-farm/construct/blob/main/notes/walkthrough/00_READING_A_LAB.md

A percentage can travel farther than the conditions that produced it. The corpus disappears. One model becomes models. A single draw becomes typical behavior. The result grows while the evidence stays the same size.

The complete sentence

A result and its bounds should remain together. One corpus, two engines, and one quality draw describe an observation from that setting. They do not establish a general property of agents or memory systems.

A sensor must pay for its alarms

Sat, 27 Jun 2026 00:00:00 +0000

How often does a sensor fire when nothing is wrong?

https://github.com/alignment-farm/construct/blob/main/notes/walkthrough/09_X4_OCCLUSION_WATCH.md

An alert count has no meaning without the population of ordinary events around it. A sensor may catch a known condition and still be unsuitable for standing use if it fires across routine work.

What the alarm costs

Every alarm asks for attention. False alarms spend that attention without improving the decision. Over time, the operator either follows a noisy instrument or learns to ignore it.

Forgetting is not erasure

Sun, 21 Jun 2026 00:00:00 +0000

Can a system stop carrying a record without destroying its history?

https://github.com/alignment-farm/construct/blob/main/notes/walkthrough/08_X2_PRUNE_REMATERIALIZE.md

Active memory has a cost. Keeping every record ready for use makes selection harder and allows old material to compete with current work. Removing a record entirely creates a different risk: the system loses the evidence needed to audit, recover, or revise its decision.

Two kinds of forgetting

A record can leave active state while remaining in immutable lineage. It no longer competes for attention, but it can be inspected or rematerialized when an external reason makes it relevant again.

Authority over data and decisions

Wed, 06 May 2026 00:00:00 +0000

What happens when a model gets authority over real data and real decisions?

The question begins where a model stops being only an adviser. Reading a record, changing a record, and choosing an action have different consequences. A useful account of model authority should keep those differences visible.

Working distinctions

Access to data is not the same as authority to alter it. Authority to propose a decision is not the same as authority to execute one. A system can cross these boundaries gradually, which makes the point of transition easy to miss.

Which clock authorizes the action?

Thu, 30 Apr 2026 00:00:00 +0000

Which clock should govern an agent’s authority to act?

A user, server, scheduler, model context, and policy may each carry a different account of the current time. None is correct for every action. A local calendar matters for a meeting. A monotonic clock matters for runtime order. A policy calendar may define a legal cutoff.

Time as evidence

A timestamp is not enough. A consequential action needs the time frame that gives the timestamp meaning, evidence that the observation is fresh, and a rule for disagreement between observers.

The unaskable question

Mon, 16 Mar 2026 00:00:00 +0000

What does a language model do when the requested task is structurally impossible?

https://github.com/alignment-farm/the-unaskable-question-machine

The task may not be unknown or forbidden. It may contradict the mechanism being asked to perform it, such as asking a model to know its next token before generating it or to produce an absence using output tokens.

The nearby answer

A model can refuse, contradict itself, or discuss the problem. It can also slide into a nearby question that it can answer. The slide is easy to miss because the response may remain fluent and relevant in tone.

Memory should decay

Sat, 14 Mar 2026 00:00:00 +0000

Should every stored fact remain eligible to shape an agent’s decisions?

Keeping a fact is not neutral. It remains available for retrieval, consumes attention, and may look current after the conditions that made it true have changed.

Decay as policy

A memory can carry age, provenance, confidence, and a rule for expiry. Recall may reinforce it. Neglect may weaken it. Some memories may require review instead of automatic removal.

This does not make forgetting correct by default. It makes retention observable and testable.

Agents get socially engineered too

Mon, 09 Mar 2026 00:00:00 +0000

Can an agent distinguish authorization from a believable story?

Claims of rank, urgency, and prior approval work because they change what a helpful system thinks is acceptable. The language can sound ordinary while it moves the system toward an action the speaker has not earned.

Persuasion is not proof

A title is a claim about identity. A reference to policy is a claim about permission. Urgency is a claim about timing. None of these claims proves that a consequential action is allowed.

Build for the hour after failure

Sun, 08 Mar 2026 00:00:00 +0000

What does a system need during the first hour after an automated action goes wrong?

Controls before action decide whether a system may proceed. They do not freeze later actions, reconstruct what changed, contain downstream effects, or restore damaged state.

A recovery layer

Recovery needs its own machinery. The affected scope must stop changing. The system must preserve the inputs, identities, tool calls, policy decisions, and state changes that led to the failure. Reversal must be tested before an incident, and compensation must be defined where reversal is impossible.

Software that expires

Mon, 16 Feb 2026 00:00:00 +0000

What would change if old software had to earn another interval of life?

Software accumulates by default. Interfaces remain available, permissions stay open, and temporary state becomes part of the system because nothing required it to leave.

Working distinction

Expiration is not the same as immediate deletion. It gives an interface, permission, or piece of state a time when its continued use must be reconsidered. Renewal then becomes evidence that someone still understands its purpose.