A manager I can talk to

Stage first. This arrangement was opened on 12 September 2026 and covers one direction of mine, a game idea. Three days on, the status block that direction keeps for itself reads stage INTENTION, and its next action is a verdict I owe it plus one question I have not answered. Nothing about the game is designed. What works is the plumbing, and the last two sections say what does not.

The itch

My projects run through one AI orchestrator. It holds every direction at once, so a chat about one of them is a chat with the thing that runs the whole company, overhead included. What I asked for, in my words that morning:

ideally I want to be able to chat to codex or Claude code about this particular direction. So the challenge is here context sharing, like ideally some kind of shared realtime memory

I want to be able to go and chat directly with orchestrator of that particular vertical. So we kind of starting to create a hierarchy of orchestrators (or in real world managers? As analogy)

Two agents took the question blind, neither seeing the other’s answer, and a third judged the points where they disagreed. A concluded debate is a decision here, so the verdict was built the same day and I reviewed the result, not the plan.

The decision

The folder is the memory. No memory service, no database, nothing hosted. Both clients I use, Claude Code and Codex, read whole files off the same disk, and the record is four files, small enough to read whole every time. The test that would change this is written down: a question a full read plus a text search cannot answer. None has arrived.

Git is the archive. A decision is not taken until it is written, dated and appended to the decisions file, and the conversation that produced it is disposable. That is the assumption the whole shape rests on.

One contract, two readers. The instruction file is the same bytes for both clients, one filename being a symlink to the other. That symlink is the claim, so the folder’s own push gate refuses a push that turns it into a copy. One level up, the two clients do not load the same thing, and that bug set the build order.

Decision rights per level, in a table. It lives in the folder’s contract, so both clients load it when a session opens. Below is that table as the file holds it, with local paths and internal tool names taken out and nothing else changed. It calls me by name in the third person because its readers are two programs.

Level	Decides alone	Records it where	Never decides
Oleg	Rank. Money and any binding commitment. Publishing anything public. Taste and shape. Identity and red lines. Kid exposure. Whether this game may use the actual worlds or only their mechanics	His words, quoted verbatim into the decisions file by whoever heard them
This vertical’s orchestrator	Everything inside this vertical: the design, the stack, scope, sequence, what to build next, what to test, what to kill. Its own commits and pushes. Its own builder jobs	The decisions file, dated and append-only; then the handoff block at the top of the status file	Rank. Spend. Any commitment. Publishing. Writing into another repo by hand
The house orchestrator	Which verticals exist and their slot. Cross-vertical conflicts. The house rails	Its own files, and the one mail file here	Anything inside this vertical’s design. It reads the block; it does not answer for this vertical
Builders	Nothing. They execute a brief and return evidence	The job outbox, or the report	Scope

The one running everything else reads a single line. The direction keeps a short block at the top of its status file: stage, next action, when it was updated, whether it needs me. A reader prints one line per direction from that block, inside a sweep that already runs every few minutes, and reads nothing else. Activity detection was not built, because the daily board already scans every repo on the disk for recent commits. Both blind designs proposed a fresh detector without looking for the one that exists.

Realtime was refused. A thread post reaches my phone in about two minutes and nothing waits on anything faster. A watcher polling every twenty seconds was proposed for a repo with one commit in it, and refused. The trigger for building one is written down: the third direction to get this treatment, and then one watcher for all of them.

The direction talks to my phone itself, on the one thread it may post to, and my reply lands in the record it reads when a session opens. Nothing carries a message between us. Me carrying content by hand is the single thing this exists to prevent, and it is a kill condition.

One file goes the other way, an append-only mail file that only the house writes. The verdict was its first entry. There is no channel back, because the status block already carries everything the direction has to say.

So every channel is one file with one writer, and every arrow below points one way.

From	To	Carries
Oleg	vertical	my words, in the folder or as a reply on its thread
vertical	Oleg	a post on its own thread
vertical	house	the handoff block: stage, next action, whether it needs me
house	vertical	one append-only mail file
Oleg	house	rank, in my words
vertical	Builders	a brief
Builders	vertical	a diff and the evidence for it

The bug that set the order

Codex loads a global instruction file: the house rules, plus a builder contract that ran to 57 lines. That contract opened by telling its reader it is the builder, that the orchestrator plans and it executes, and that its deliverable is a diff. All true inside a build sandbox with a brief in hand. In this folder, where Codex is the orchestrator, every line of it is wrong, and it loads above the repo file that says otherwise.

One blind design saw those exact bytes and wrote that they were harmless today. The judge called that the single worst call in either document. The fix was one paragraph: the contract now opens by naming where it binds, and says that anywhere else its reader is that repo’s own agent.

So “identical context” turned out narrower than I asked for. Both clients get the same rules and the same repo contract. On top of that, the Codex side carries a builder identity that now knows its place, and the Claude Code side reads a copy of the house rules that can be hours ahead, because one is a live link and the other is regenerated on commit.

What we examined

Sixteen references, each with the mechanism examined and whether it was adopted, adapted or rejected, with the reason. Every row is from memory. Neither design nor the verdict made a network call that day, so none of it was checked online and current shapes may differ.

The sixteen, one line each

#	Reference	Mechanism examined	Verdict and reason
O1	Letta / MemGPT	Bounded named memory blocks the agent rewrites in place, plus archival paging	Adapted the bounded block as the status block. Rejected self-editing and the archive: a block written from belief has no source to check against
O2	mem0	LLM extraction of atomic facts into a store	Rejected. Hosted means my words leaving for somebody else’s server. Self-hosted still makes a model the author of the record
O3	Zep / Graphiti	Bi-temporal edges, so a superseded fact keeps when it stopped being true	Adopted as a principle, already the append-only decisions file. Rejected the software: two daemons whose absence nothing here detects
O4	LangGraph	Thread-scoped checkpointer versus cross-thread store	Adapted the split: the working tree is the checkpoint, the committed repo is the store. Rejected the dependency
O5	CrewAI hierarchical process	A manager agent owns delegation and validates output	Adopted as the rights table. Rejected as a runtime: an approving manager is a relay, and its plan dies with the process
O6	AutoGen / AG2 GroupChatManager	One shared message list, with explicit next-speaker selection	Rejected the shared transcript, which costs the house context in proportion to how much the direction talks. Kept “who may write next” explicit, as ownership by file
O7	OpenAI Agents SDK handoffs	Handoff as a tool, with an input filter	Adapted the filter: the house receives the decision, never the conversation. Rejected in-process transfer, since a file survives both sides dying
O8	Google A2A	Agent cards at a known URL, task lifecycle over HTTP	Adapted the card, which the repo contract already is. Rejected the transport: a port and an auth story to cross a directory boundary that is a file read
O9	MCP memory server	Entities and observations in local JSONL, exposed as tools to any MCP client	Rejected for now, and named as the upgrade path. It is the one option putting a single store behind a single interface in both clients. Trigger: a question a full read plus a text search cannot answer
O10	Claude Code instruction hierarchy and hooks	Global file then project file, path imports, session-start hooks	Adopted the hierarchy and the hook. Rejected imports: Codex does not resolve them, so an import is context one reader lacks
O11	Cursor rules	Per-directory rule files with glob scoping	Adapted scoping, which is the argument for the identity fix above. Rejected the format: a third instruction dialect is a third thing to keep true
O12	Aider	Every edit becomes a commit, so history is the memory	Adopted git as the archive and one commit per decision. Rejected auto-commit per edit: commit subjects here get read, and a stream of them is noise
O13	Beads	An issue tracker as git-backed JSONL in the repo	Not adopted today, recorded as the next adoption once the direction holds more open work than one next action. Both designs flagged low confidence in its current shape
O14	Karpathy’s llm-wiki pattern	Typed pages, wikilinks, an index, an append-only log, an orphan lint	Adopted the discipline for this direction’s notes once there are more than a handful. Rejected as the home: that wiki is cross-project and this context is private
O15	My own per-repo working-memory files	A hand-written one-screen status file	Adopted the shape, rejected the mechanics: all three that exist are stale, one headed with a date a year before the file’s own modification time. This one has a stamp a gate can fail on, and a reader
O16	The house’s own per-repo build lock	A claim file published atomically, leases taken in a fixed order, a sweep for a dead holder	Adopted as the reason the direction dispatches its own builders, and as the reference for the thread lock described below

What changed in the three days since

The thread lock shipped. Two programs append to the thread I read on my phone. Each derived the next entry number from the last one it had read, with nothing serialising them, and on 25 August that race issued the same number twice, lost one of my replies, and left a decision filed under the wrong question. The verdict made a lock the precondition for this direction posting to me at all. It landed in both writers on the afternoon of 12 September, so that door is open.

The freshness gate is not the rule the verdict wrote. The verdict asked that when a record file moves in a push, the block’s timestamp must be no older than the earliest of those commits, and claimed this passes a normal write-then-commit. It does not. You save the file at one second and commit it at the next, so the stamp is always slightly older than the commit carrying it, and the rule as written refuses every ordinary push. The shipped gate walks the pushed commits oldest first and asks that the last commit touching a record file is at or before the last commit that moved the block. The refusal the verdict would have caused is a selftest case, forced and shown firing.

What is unproven

• One direction, three days. The falsifier is written: after my first real sessions there, the house reads only the block and the decisions file, says what it believes was decided, and I say right or wrong. Wrong twice and the assumption underneath all of this is false. It has not been run.
• The gate watches three files, and the folder is bigger than three files. Four commits landed under the notes directory on the afternoon of 12 September while the block still said the next action was for me to open the folder. The gate passed each one correctly, because notes are not the record. A reader looking at the block that day would have been told something three sessions out of date, and only a person reading the commits would have known.
• The Codex half is an instruction, not a mechanism. A session-open command prints the stage, the last decisions and anything waiting on me, then stamps that it ran. Claude Code runs it from a session-start hook, shown to fire on 12 September by opening a session and watching the event file gain a line four seconds later. Codex has no equivalent hook, so it is told by the contract’s first line. A skipped run shows up only afterwards, as a commit with no open event before it.
• The phone route into the session is armed, and that is all. A second route, from my phone straight into a session in that folder, needed a one-time approval on the laptop and got it the same afternoon. Nothing has come through it that I can point at.

What kills it

A quiet fortnight judges the game. These five judge the arrangement, and they were written before it ran.

• Fewer than three sessions in that folder in the fourteen days after it landed, which run out on 26 September: kill the arrangement, keep the repo.
• The block stale past seven days twice while the direction is active, or the readback above wrong twice: kill this shape and open the memory-layer design, starting from the MCP memory server.
• I relay content between the house and the direction, even once: fix the hop if it can be named, kill the level if it is structural.
• A red line originating in the direction, a publish, a spend, a commitment, an exposure: kill the autonomy that day.
• The house reads more than the one line on more than one sweep in five, over four weeks: kill, because the saving was not real.

Kill means an ordinary house-run direction again. The repo and the whole record stay, and an epitaph names the cause and the condition that would reopen it.

Three days in, the arrangement has survived one real correction and shipped the lock it was waiting on. The fortnight is the test.