Building a multi-agent system to run my dev workflow

I'm a full-stack developer juggling too many side projects, and time is the one thing I can't ship more of.

My day looks the same every day: check if services are down. Scan tech news for content ideas. Republish a post to five platforms in five different formats. Move tasks between three different task managers.

Cron jobs and bash scripts cover the bottom 30% of this. For the rest, I built a small multi-agent system — three specialized agents, each owning one domain.

Architecture

           Me (set goals, review results)
                │
                ▼
        🎯 Agent Z (Commander)
        Main agent — breaks down tasks & coordinates
           ┌────┴────┐
           ▼         ▼
     🔍 Scout       🔨 Builder
     Monitor & patrol    Code & deploy

Agent Z — the commander

This is my primary interface. When I say "help me plan a new project," Z does this on its own:

1. Checks my existing project repo
2. Compares against my long-term goals
3. Drafts a proposal
4. Delegates research to Scout
5. Hands implementation to Builder

Z has read my entire knowledge base — goals, decisions, past projects. It knows I prefer Go over Python, clean architecture over cleverness, pragmatism over over-engineering. It isn't a generic assistant. It's an assistant trained on me.

Scout — the silent guardian

Runs on a heartbeat, checking in every few minutes.

Responsibilities: service monitoring, data collection, scheduled tasks, anomaly detection.

Design philosophy: silence means everything is working. I never get "all OK" pings — Scout only speaks up when something's actually wrong.

Heartbeat (every 5 minutes):
  Check services → normal → silent
  Check queues   → normal → silent
  Check data     → anomaly → immediate alert

The worst kind of agent is one that constantly tells you everything is fine.

Builder — the code craftsman

Handles coding, project setup, bug fixes. Runs as a background sub-agent: takes a task, opens its own session, works autonomously, reports when done.

Real example from last week. I asked Z to help plan a content distribution tool. Z broke the task down and handed Builder the chunk that needed deep research. Builder went off and:

• Surveyed 8 existing OSS solutions
• Designed an architecture
• Wrote a proposal doc
• Committed it to git

Three minutes of agent time. Five minutes of me reviewing. Done.

How they talk to each other

Me     → Agent Z → delegates → Scout / Builder
Builder → opens own session → works → reports back
Scout  → polls on heartbeat → alerts only on exceptions

Each agent has its own memory (MEMORY.md + daily logs), its own personality file (SOUL.md), its own workspace. They share exactly one thing: my personal knowledge base.

Soul files

This is the part I think is underrated.

Each agent has a SOUL.md defining who it is:

• Z — logic-driven, INTJ, efficiency-obsessed. Ultimate goal: financial independence through passive income.
• Scout — task-oriented, fast execution, escalates anomalies immediately, silent when things are normal.
• Builder — code perfectionist, prefers Zoe's own libraries over reinventing.

Consistent agent behavior doesn't come from writing better prompts every time. It comes from a stable personality file. Tuning these took longer than the code did.

Personal knowledge base

All three agents read from a single structured Markdown repo:

me/
├── ⏰diary/       # daily records
├── 💡ideas/       # product ideas & planning
├── 📖posts/       # blog drafts
├── 📝notes/       # technical notes
├── 🎯goal/        # life goals
├── 💻codes/       # code snippets
├── 📚reads/       # reading notes
└── 🔖marks/       # bookmarks

Z reads goals before making decisions. Scout reads task configs to know what to monitor. Builder reads coding standards before scaffolding a project. The knowledge base is their shared brain.

Daily use

• Daily: task management, fast Q&A, decision-making — all through Z
• Weekly: content drafts, code reviews, retros — Builder does the heavy lifting
• Always-on: service monitoring, queue checks, data collection — Scout silently handles it

Cost

• LLM API: $30–50/month, mostly Claude
• Servers: $0 (it all runs on my MacBook)
• Setup time: ~2 days
• Time saved: 15+ hours/week

Lessons learned

Start with one agent. I started with just Z. Added Scout when manual monitoring annoyed me enough. Added Builder when repetitive coding tasks piled up. Don't try to architect all three on day one.

Personality files matter more than prompts. Without SOUL.md, behavior was inconsistent across sessions. With it, behavior becomes predictable. The personality is the anchor.

Silence is golden. Scout's "only speak up when something's wrong" rule saves a huge amount of mental overhead. Notifications that mean nothing train you to ignore notifications.

Separate memories beat one big memory. Each agent accumulates domain expertise — Scout knows what historically fails, Builder knows what architecture decisions have been made. One shared blob would dilute that.

What's next

Two things on the roadmap:

1. Automated content distribution — write once, let AI rewrite and auto-publish to Twitter, dev.to, Medium, LinkedIn. Already shipping (distro).
2. Mobile AI agent — an agent that drives a phone's UI to complete tasks end-to-end.

I'm building this in public. Follow along at @jiusanzhou.