Notes · Operations

Agent context needs its own OFA

Before OFA, Oracle consultants couldn't find the files at a new client site. In 2026, every agent setup is laid out differently. What a 35-year-old install standard teaches us about context engineering for on-call agents.

A 3.5-inch floppy disk whose label reads $OPS_HOME, operations context, layout v0, 1991 to 2026

Vitaliy Mogilevskiy · November 14, 2026 · 10 min read

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 talkThe OPS Framework
CLAUDE.md, loaded every sessionCLAUDE.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 demandrunbooks/*.yaml: 25 procedures, each keyed by what the operator types, like lag {tablet} or dig {tablet} at {time}
A directory of markdown memoryknowledge/*.md, a Q&A index with tags, confidence and last-updated dates, and a catalog of dashboards and queries
Load progressivelyOne routing line, then one runbook, its pitfalls and its notes. Nothing else.
Agents record what they learnpitfalls: in the runbook, treated as hard constraints, so each mistake costs at most one session
Versioning and attributionRunbooks in git; every command logged with its session, step, exit code and context tags
A hash check that lives in the harnessDeterministic parsers: every number in a report comes from code
Permission tiersconfirm: true before any state change; channel posts are always drafts
Stale memories“Always read config.yaml; hostnames written anywhere else may be stale”
DreamingNot 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:

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:

  1. One root. Tools find everything from $OPS_HOME.
  2. Name procedures after what the operator types. The routing table is the index.
  3. Constraints live next to the procedure they constrain. A pitfall belongs in the runbook, not in a general notes file nobody loads.
  4. Scope by directory, permission by directory. Shared rules are read-only to agents; per-capability notes are writable.
  5. Numbers come from code. The model never reports a number it computed itself.
  6. Log every command with its session and context. The log is the audit trail, the recall index and the dream input.
  7. Agents propose; people promote. Nothing reaches common.md or a pitfall without review.
  8. 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.

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.