DEV Community

Cover image for My Multi-Agent System Built on Claude Code and Obsidian
Yasmin Suellen
Yasmin Suellen

Posted on Originally published at yasminsuellendev.substack.com

My Multi-Agent System Built on Claude Code and Obsidian

Yasmin Suellen · Software developer building, documenting decisions, tradeoffs and fixes behind the systems I build.

For a while my routine had more operational parts than I could hold in my head. An Information Systems degree with real deadlines, a developer job, a network growth with its own pipeline, content I wanted to keep updating, personal admin that never stops. None of it was hard on its own, what cost me was the repeated work around it. Remembering where each goal stood, tracking by hand and doing again tasks I had already mastered.

So I started building a system to carry that part for me. It runs on an Obsidian and Claude Code and this is its current map.

The vault as the single source of context

Everything the system knows lives in one Obsidian vault, split into four areas: Study, Work, Personal and Infrastructure. Each area has one roadmap file per ongoing goal with its decisions, progress, and next steps. Instead of explaining context to AI in every session, the system reads those files.

The split into areas isn't cosmetic. Study has fixed academic deadlines, work has applications and content that compete for the same hours. In a single list, the louder Work tasks kept winning and Study kept losing. Separate areas protect the slower goal from being crowded out.

Agents and skills

On top of the vault I run five agents organized as a scope hierarchy. At the top, one coordinator only handles what spans more than one area. Below it, four agents are each scoped to a single area, reading and writing only inside that area's folder. No agent reaches into another's scope, so two tasks running at the same time never step on each other's files.

Their recurring tasks are packaged as skills, written instructions for one specific job, like opening each day with a summary of my goals, logging a session into every area it touched or sorting a raw list of ideas into the right projects.

A behavior that must run every session stays a standing rule. Anything occasional or that needs a consistent output format, becomes a skill called on demand.

What a day looks like now

The first session of the day opens with a short summary of every roadmap so I start from shared context instead of from memory. Then the coordinator wakes each area agent once and each one checks its own standing tasks. On days my calendar has a job search block, one agent looks for postings that match my criteria and adds them to a list for my review. Once a week, another agent audits the whole system for anything out of sync.

When I want something done without waiting on it, I write a request as a file, an agent picks it up, appends its answer, and marks whether it needs my reply. At the end of a session, the work gets logged into each area it touched.

What changed in my routine

The difference isn't that I do less. It's what I spend my attention on.

  • Finding, organizing, and preparing → handled by the system
  • Deciding what to apply to, work on, or change → still mine
  • Study time → protected instead of absorbed
  • Improving my own process → something I now have room for

Nothing irreversible happens without me. Job postings wait in that list until I review them and the final submit on any application always waits for my explicit go. The system prepares, I decide.

A few decisions that held up

Boundaries enforced by access not by wording. For coding work I use a small team of agents, and the reviewer isn't given any file-editing tools. Its role is enforced by what it can access, not only by how its prompt is worded.

Permissions without open ends. Every command an agent can run without asking is either an exact match or bounded by fixed text on both sides, so a matched command can't carry another one chained after it. One folder with sensitive data is blocked for every read and search at the permission level.

An audit that reports instead of fixing. The weekly check compares every mirror, permission description and map entry against reality and hands me the findings. It never fixes anything itself, because an automatic fixer that misreads a mismatch spreads the problem faster than it solves it.

Instruction files without history. Skills state the current rule only, no dates, no notes about how things used to work. The history lives in the roadmaps, not in the file an agent executes.

It's maintained like code

This isn't a setup I finished. A system like this keeps evolving. Every time a folder gets renamed or a rule changes, the instructions that depend on it have to evolve too and keeping them aligned is part of the work. Recently I found two cases. An agent couldn't load a skill it needed after I trimmed its configuration, and a staging step was marking job postings as applied before anything had been submitted. The second was fixed the same day, the first has a workaround while I choose the cleaner fix. Neither was a model failure. Both were instructions that no longer matched reality.

That's the actual work behind it. Building the agents was the easy part. Keeping them accurate is what makes the system worth trusting and it's what gives me back the time to study, decide and keep improving instead of executing the same steps again.

Top comments (0)