Four months ago I published Obsidian as a Personal OS for AI Coding Agents . The argument was simple: AI coding tools become more useful when they stop starting from zero.
I still believe that.
But the system taught me a harder lesson: memory is not enough.
An agent can remember your stack, repos, goals, and past corrections. It can still pick the wrong task, ignore a dependency, use too much authority, or say “done” before the evidence exists.
The first version solved the cold start. The second version is about earning trust.
Update #1
This is a new article, not a rewrite of the March post. I plan to publish one evidence-based snapshot every quarter so the series records how the system evolves.
Agent Brain v2.0.0
What changed
The biggest change is not the amount of information in the vault. It is the role that information plays.
| March 2026 | July 2026 |
|---|---|
| The vault remembers | The vault stores intent and evidence |
| A prompt starts the workflow | A task contract defines the work |
| The agent reports completion | Checks and review decide completion |
| More context feels better | Context loads only when needed |
| Autonomy means more agents | Autonomy means bounded authority |
The model is now a replaceable worker inside a larger process.
The loop matters more than the model inside it.
intent
-> bounded task
-> isolated execution
-> deterministic checks
-> independent review
-> artifact + evidence
-> learningAny capable runtime can execute a task. The surrounding system should still define what the task is, what it may touch, what evidence it must return, and when it can advance.
I made context too big
The first article celebrated loading project context at session start. Then I pushed that idea until the startup instructions grew beyond what the runtime could reliably read.
This is the trap with second-brain systems: once every detail feels useful, deletion starts to feel dangerous. The result is a startup document that treats every old fact as equally important.
The current entrypoint contains only critical rules, stack defaults, and pointers to the real sources of truth. Everything else loads through a relevant skill, repository documentation, vault search, or an explicit file read.
startup rules
-> task-specific skills
-> repository documentation
-> relevant notes and evidenceThe deletion was the feature
Persistent memory does not mean permanent attention. The system should remember what matters, then load only what the current decision needs.
Commands became versioned skills
In March I had slash commands scattered across tools. They worked, but each runtime wanted a different adapter and every global install created another source of drift.
The v2 template keeps one project-local source for each skill and generates portable runtime adapters from it. A deterministic check rejects stale adapters, missing workflows, and invalid structure. The migration keeps existing notes intact.
A skill is no longer just a prompt shortcut. It is a workflow contract with inputs, boundaries, tools, an artifact shape, and verification.
Two skills show the difference:
/review-gateseparates generation from independent judgment and records findings that escape each review round./shipinspects the current changes, commits and pushes them, syncs the vault, and logs the commit to the daily journal.
The contract can survive a change in model or runtime because it lives above both.
Autonomy needs boundaries
I audited the old autonomous path and found enough disagreement between task state, review, and completion evidence to stop it.
The lesson was simple: more agents would have made the same problems happen faster.
The replacement starts with less authority. Each task declares its allowed scope, exact checks, protected paths, risk, and expected artifact. Execution stays isolated. Completion requires evidence.
{
"allowedPaths": ["src"],
"checks": ["bun test"],
"protectedPaths": [".git"],
"risk": "low",
"artifact": "commit"
}Authority must be earned
Automatic merge, deploy, release, and durable-data mutation stay disabled until repeated tasks and recovery drills justify more authority.
The vault became an evidence layer
The original system mainly stored notes and work history. The current vault also keeps experiments, verification reports, decision trails, rejected alternatives, and failure artifacts.
That changed the questions I ask.
Before:
What do I know about this topic?Now:
What evidence supports this decision?
What failed the last time I tried it?
Which claim is verified, inferred, or still unknown?
What artifact would let someone else check my answer?The second set of questions produces slower answers. It also produces answers I trust more.
What is working and what remains unproven
Review-gate is already useful
/review-gate is one of the parts I already trust. It runs deterministic checks first, then focused review passes selected by what changed. Each finding needs evidence, and every miss from an external review becomes a new gate.
Its success metric is external findings per review round, trending to zero. That gives me a concrete quality loop that gets stricter with use.
Retrieval still needs maintenance
File-backed memory avoids platform lock-in, but an index can still become stale. Retrieval needs a freshness check before the system can treat missing results as missing knowledge.
The evidence needs to leave my environment
Most of the current evidence comes from my own work. The next update needs external use and before-and-after task data. Otherwise the system risks becoming a better way to agree with itself.
Agent Brain is now versioned
v1.0.0 preserves the March template. v2.0.0 adds canonical skills, portable adapters, a migration guide, and integrity checks. Existing vaults can update the workflow files without replacing their notes.
What did not change
Obsidian is still the persistence layer. Markdown is still the escape hatch. Git still gives the system history. The seven-folder structure still works. /morning, /today, /pulse, and /ship still turn work into durable context.
The principle from the first post also survives:
Your AI should know your failures better than you do.
I would add one line now:
And it should not be allowed to hide its own.
The quarterly protocol
The next update should be based on evidence, not memory or vibes.
compare: previous_release
publish:
- one verified improvement
- one failure that changed the system
- one claim that remains unproven
- the next measurementThe goal is not to announce a bigger second brain. It is to build a smaller, clearer system that can explain what it did, show the evidence, recover when it fails, and improve without treating every new layer as progress.
Four months ago, I wanted my AI to remember me.
Now I want the whole system to deserve my trust.