The easiest way to make an AI system feel powerful is to give every session everything. The easiest way to make it expensive, slow, and confused is the same thing.
Loomfield is getting more useful as I make its context smaller. The goal isn't to starve an agent of information. It's to give each piece of work the narrowest complete view: enough to understand the job, the authority, and the relevant history without paying to reread the whole world.
That's pushed the architecture toward focused retrieval and short-lived sessions. A large system can still do serious work when each turn has a clear job, a durable place to put the result, and a clean way to ask for more only when it needs it.
Context is a budget
Every token placed in front of a model competes for attention. A long prompt can contain more facts and still produce a worse decision because the important relationship is buried inside background that doesn't belong to the current task.
Loomfield now treats orientation as a map, not a shipment. A session starts with connection points: the active project, current focus, relevant constraints, and addresses for deeper material. It can then retrieve a project brief, one note section, one task set, or a small group of earned lessons. The default is a slice, not a dump.
Retrieval needs a budget, not an arbitrary item count. A small correction may be worth more than five generic observations. Relevance, trust, and weight decide what earns space while the total stays small enough for the model to see the work clearly.
Short-lived sessions beat a standing mind
A standing orchestrator sounds efficient because it is already awake. In practice, it slowly turns conversation history into system state. Old assumptions remain in context, new rules arrive out of band, and the orchestrator begins coordinating from a memory that no one can inspect cleanly.
Short-lived dispatchers behave differently. They wake for a defined job, load current rules from the durable system, do or route the work, record the result, and settle. The next dispatcher starts fresh from the project rather than inheriting a long private monologue.
Durability still matters, but it belongs in the project, decision, task, capability, or journal—not in the hope that one conversation stays alive forever. A session can be resumed when continuity is useful. It should never become the only place continuity exists.
One micro-session, one bounded change
Mechanical changes are a good example. Checking a task, appending a status entry, or applying an approved note edit should not require a giant reasoning session. It still needs the structure rules, a current read, narrow authority, and a verification step. The right answer is not to remove the intelligence from the path. It's to give a small session one clear mutation contract.
A micro-session can receive the target, the expected current state, the allowed operation, and the deny floor. It reads the current item, applies the bounded change, verifies what landed, and reports a durable result. If the current state doesn't match the expected state, it stops instead of improvising over someone else's work.
This pattern keeps permissions legible. A session that can update one project note doesn't need broad authority over every project, repository, or external system. Narrow scope reduces both token use and the size of a possible mistake.
Use the smallest capable model
Model choice should follow the shape of the decision. A mechanical status append with explicit inputs doesn't need the same reasoning depth as a contradiction, an architecture trade-off, or a high-stakes external action.
Loomfield separates those classes. Cheap, fast models can handle constrained state changes and straightforward classification while preserving the same read-check-write-verify discipline. Stronger models are reserved for ambiguity, synthesis, planning, and situations where the cost of a shallow answer is materially higher than the cost of the call.
The important word is capable. Routing everything to the cheapest option is not efficiency if a person has to repair the result. Routing everything to the strongest option is not rigor if most of the work was clerical. The system should know which kind of thinking it is buying.
Pass pointers, not transcripts
Agent collaboration can recreate the same context problem at a larger scale. If every session forwards its full transcript to every other session, a coordinated system becomes a machine for multiplying tokens and ambiguity.
Loomfield passes pointers by default: the project address, the decision that changed, the output artifact, the session state, or the exact question that needs another mind. The receiving session can inspect the durable source when necessary. Display-only journal events can show a human how work moved without injecting every coordination detail back into model context.
A good handoff says what changed, where the evidence lives, what remains open, and what authority the next session has. It doesn't make the next session relive the entire conversation that came before it.
Efficiency has to remain honest
Token reduction is easy if the system quietly stops checking its work. It's moving cost from the model bill into rework, uncertainty, and lost trust.
The useful measure is completed, verified work per unit of attention. Did the session load the rule that mattered? Did it see the current state? Did the change land? Did the result make the next session easier? A smaller context is only better when those answers remain visible.
That's the direction I'm taking Loomfield: compact starts, deliberate retrieval, bounded sessions, model choice matched to the judgment, and durable results that outlive every provider. Spend intelligence where it changes the outcome. Keep everything else lean enough to understand.