Nobody could find the files
In the early 1990s, Cary Millsap was a consultant at Oracle with a recurring problem. Every client site laid out its database differently: different mount points, different directory names, logs and admin scripts wherever the last DBA had put them. On a return visit, he sometimes had to query the database just to find out where its own files lived.
So he wrote himself a standard. Oracle presented it at the International Oracle User Week in 1991, and the final version was published in 1995 as the Optimal Flexible Architecture: OFA. Millsap later admitted it wasn't really an architecture. It was a configuration standard. That's exactly why it worked.
I learned Oracle inside OFA. When I patched E-Business Suite with
adpatch, the tool needed to know two things,
$APPL_TOP and $ORACLE_HOME. Everything else it found on its
own, because everything else was where the standard said it would be. Drop a DBA into
an unfamiliar OFA environment and they knew where to look on the first morning.
I've been thinking about OFA a lot lately, because agent context is where Oracle
installs were before 1991. One repo has a CLAUDE.md, the next an
AGENTS.md, the next a rules folder. Skills live in one place, notes in
another, memory somewhere else. Every new agent setup starts by working out where
things are.
What Anthropic means by context engineering
Anthropic's 2025 post on context engineering describes it as the next step after prompt engineering: managing everything the model sees, not just the prompt, and keeping it to the smallest set of high-signal information that gets the job done.
At AI Native DevCon in London this June, Lamis Mukta of Anthropic's Applied AI team gave a talk called Learning while you sleep: beyond memory to dreaming (31 minutes, worth watching in full). Her opening argument will be familiar to anyone who has onboarded an engineer: a smarter model doesn't know your organization. Intelligence alone doesn't compound. Without context, every task starts from zero and the fiftieth run is no better than the first.
She then traced how agent memory has evolved: from a single CLAUDE.md
loaded at the start of every session, to memory tools the agent calls itself, to
skills (procedures whose short header the agent scans and whose body it loads only
when needed), to a plain directory of markdown files the agent reads and writes with
ordinary tools like bash and grep. Her summary of current
best practice: model these memory systems “just as file systems.”
Three lessons ran through every approach that stuck: use human-readable markdown, load progressively instead of all at once, and let agents record what they learn. For production, she added four principles: version every write and record which session made it, guard writes with a content hash so concurrent agents don't overwrite each other, tier permissions from read-only organization knowledge down to writable per-agent notes, and keep the store portable.
The second half of the talk introduced dreaming, which I'll come back to.
The same shape, built for on-call
This spring I built the OPS Framework, a toolkit for on-call and incident response on a large Vitess fleet, with Claude Code as the execution engine. I wasn't following a spec. I was trying to stop two failures I wouldn't accept on production databases: the same data producing a different answer on a different run, and the same mistake repeated in the next session.
When I watched the talk this month, I recognized almost every layer.
| The talk | The OPS Framework |
|---|---|
CLAUDE.md, loaded every session | CLAUDE.md: a routing table from what the operator types to the runbook that handles it, plus the hard rules (access, quoting, how to report results) |
| Skills: procedures, header first, body on demand | runbooks/*.yaml: 25 procedures, each keyed by what the operator types, like lag {tablet} or dig {tablet} at {time} |
| A directory of markdown memory | knowledge/*.md, a Q&A index with tags, confidence and last-updated dates, and a catalog of dashboards and queries |
| Load progressively | One routing line, then one runbook, its pitfalls and its notes. Nothing else. |
| Agents record what they learn | pitfalls: in the runbook, treated as hard constraints, so each mistake costs at most one session |
| Versioning and attribution | Runbooks in git; every command logged with its session, step, exit code and context tags |
| A hash check that lives in the harness | Deterministic parsers: every number in a report comes from code |
| Permission tiers | confirm: true before any state change; channel posts are always drafts |
| Stale memories | “Always read config.yaml; hostnames written anywhere else may be stale” |
| Dreaming | Not built yet. The data it would read is already there. |
One of her slides shows a memory file that says, in effect, “deploy with the make target, not the script; the user has corrected this three times.” One of my runbooks has a pitfall that says “run the diagnostic script locally; it handles SSH itself. Do not pipe it over SSH.” Same kind of lesson, written down for the same reason, in the same place: next to the procedure it constrains.
Two teams working on different problems converging on the same layout is usually a sign the layout is right. It's also a sign it's time to write it down.
The calculator set to radians
The limit of everything above is that the agent learns in-band: it curates memory while it does the task, with the same attention budget, and it only sees its own session. It can't notice that forty other sessions hit the same wall.
Dreaming moves that learning out of band. A separate batch job takes the memory store plus a period's worth of transcripts, including tool calls and metadata, not just the conversation. An orchestrator fans the transcripts out to sub-agents, you steer them toward what matters to your organization, and the findings come back as proposed memory changes. Each proposal includes example transcripts and how often the pattern occurred, and a person accepts or rejects it.
Her best example came from a school. If every student in the maths class gives answers in radians, the students aren't the problem; the calculator is set wrong. For agents, that's a misconfigured tool: invisible in any single conversation, obvious in the tool calls across a hundred of them.
Operations is full of radians. One of my pitfalls exists because the dashboards I query use a different metrics data source than the default. In any one session that looks like an empty graph and bad luck. Across many sessions it's a misconfigured tool.
The part I didn't appreciate until I watched the talk: the OPS Framework already records the dream input. Every command goes to a daily log with its runbook, session, step, exit code, a summary of the output, and context tags for environment, keyspace and shard. Steering is a tag filter. And when someone asked how dreaming respects permissions, the answer was that you choose which transcripts to attach. For on-call, that's “production sessions for this keyspace, last two weeks.” What's missing is only the job that reads it.
Agents write notes. People write rules.
One lesson from the talk is that agents do best when they're free to record what they think is worth keeping. For working notes, I agree. The talk is just as clear about the other side: one agent writing a bad entry into organization-wide context spreads it to every agent that reads it. That's why the permissions are tiered and why a person reviews every proposal that comes out of a dream.
For on-call, I draw the line between notes and rules. Anything an agent writes
during an incident is a note: useful, unverified, and easy to ignore. Pitfalls and
shared rules are different. My CLAUDE.md tells the agent to obey them as
hard constraints, so a wrong rule doesn't just make the answer a little worse. It
makes the agent take the wrong action on production, every time the rule applies.
That's why nothing becomes a rule until a person promotes it.
That's the same reason state-changing steps in the runbooks are gated behind
confirm: true, and why the framework posts to incident channels as drafts.
The blast radius decides who signs off, not the convenience of the agent.
The harness, not the model
During the Q&A, someone asked whether all of this is just reinventing databases. The answer was that the work is finding the boundary between what the agent decides and what the harness does deterministically. Hashing and versioning moved into ordinary code because there was enough evidence that they should never be left to the model's judgment.
That's the rule the OPS Framework is built on. Claude matches the prompt to a runbook, decides the next step, and drafts the write-up with the data before the hypothesis. Code does anything that has to come out the same twice: parsing replay data, aligning every replica on a common five-second grid, detecting and classifying spikes. Identical inputs produce identical reports. The engineer forms the hypothesis and approves anything that changes production.
Put another way: let the agent be flexible where judgment is needed, and make everything else boring. Standards are how things become boring.
What OFA actually standardized
OFA didn't tell you how to tune a database. It told you where things go and what
they're called: numbered mount points, one ORACLE_BASE, a separate
ORACLE_HOME for each version, an admin directory per database. That bought
three things:
- Onboarding. A DBA new to the site knew where everything was before they'd read a line of local documentation.
- Tooling. Installers and patch tools needed one variable. Everything else was derived.
- Coexistence. Versions lived side by side, so you upgraded by installing a new home next to the old one, not by editing the old one in place.
It's been 35 years, and Oracle's installer still defaults to OFA.
Agent context has none of the three. A new engineer, or a new agent, has to discover each repo's layout. Every tool that wants to read the context, whether it's a memory API, a dream job or a linter, has to be configured repo by repo. And there's no convention for two harnesses sharing one body of context.
The talk describes the memory store as a directory of markdown files.
Anthropic's Managed Agents
goes one step further: it fixes the root, mounting every memory store under
/mnt/memory/, and sets read-only or read-write access per store. That's
half of OFA: where things go and who can write. What goes inside a store is still up
to you. That's the gap.
A draft layout for operations context
Here's a first draft for operations work: the OPS Framework's layout, generalized, with the pieces the talk convinced me I'm missing. Call it v0.
$OPS_HOME/
CLAUDE.md routing: what the operator types -> runbook; hard rules
config.yaml environments; the only place hostnames live
runbooks/<cap>.yaml procedure: syntax, inputs, steps, confirm gates, pitfalls
knowledge/
common.md shared rules: read-only to agents
<cap>.md notes for one capability: agents propose, people merge
qa/INDEX.md, qa/*.md answered questions, with tags, confidence and date
scripts/ cmd/ deterministic parsers: every reported number comes from here
log/YYYY-MM-DD.jsonl every command: session, step, exit code, context tags
dreams/ proposed changes from out-of-band review, waiting for a person
And the rules, OFA-style:
- One root. Tools find everything from
$OPS_HOME. - Name procedures after what the operator types. The routing table is the index.
- Constraints live next to the procedure they constrain. A pitfall belongs in the runbook, not in a general notes file nobody loads.
- Scope by directory, permission by directory. Shared rules are read-only to agents; per-capability notes are writable.
- Numbers come from code. The model never reports a number it computed itself.
- Log every command with its session and context. The log is the audit trail, the recall index and the dream input.
- Agents propose; people promote. Nothing reaches
common.mdor a pitfall without review. - Plain files in git. Any harness can read them, and a new version can sit beside the old one.
It's deliberately boring. That's the point.
What's next
Holding the OPS Framework up to the talk's four production principles, it has three
gaps. Knowledge files are versioned in git, but a change isn't tied to the session
that prompted it. There's no hash check on writes, which has been fine with one
operator and won't be with a fleet of agents. And common.md is shared but
writable.
The next thing I'll build is a dream runbook: a nightly job that reads a
window of the log, filtered by tags, and opens pull requests proposing new pitfalls
and knowledge edits, each with the sessions that justify it and how often the pattern
occurred. A person merges them or doesn't.
If you run agents on-call and your layout looks different, I'd like to see it. Reply to this newsletter or comment on the LinkedIn post, and I'll fold what works into the next draft.
HASHJOIN Field Notes
New tools and field notes on running production fleets: rolling upgrades, incident forensics, and Claude-augmented ops. About once a month, no spam.
Want this layout running for your on-call team?
HASHJOIN builds it in your environment: runbooks for the incident classes that cost you most, deterministic analyzers for your signals, and the guardrails above. Fixed scope, and you own all of the code.