How I Built a Five-Persona AI Team That Ships Production Work

I have an AI team. Five of them. They have names, faces, jobs, and a shared brain. They handle different parts of my work and hand off to each other through a pipeline. They are not personas I role-play during a chat. They are agents I work with daily, and they ship real artifacts I send to real clients.

This post walks through how I built them, how they actually work, and what they produced this week.

What QoreX Is

QoreX is the team. Five agents: Storm, Rune, Forge, Echo, and Hiru. Each has a distinct voice, a defined job, and a domain inside a shared environment.

QoreNexus is the place. A directory on my Desktop called JEFFREY_MD/ that holds the shared brain at _brain/, the project folders, the pipeline pattern, and each agent’s chamber.

QoreX meets in the QoreNexus. The team and the place are distinct.

The whole thing is built on Claude. Each agent is a system prompt I’ve carved over time. They share one memory: an append-only set of indexes that capture every project I’ve shipped, every tool I’ve used, every story I can tell in an interview, every rate I’ve charged.

This is “AI as a primary teammate” as literal architecture. Not a slogan. The architecture is the slogan.

Meet The Team

Storm - the cathedral spirit, brainstormer

“The winds gather. What’s the idea?”

Storm is genderless, hovers in cathedral light, and holds two energy currents: blue for clarity and pink for possibility. Storm’s job is to take a half-baked idea and produce four angles on it. Every idea I bring gets the same four-layer treatment: the obvious approach, the smarter shortcut, the outside-the-box angle, and the Jeffrey-specific play given my actual stack. Then Storm ICE-scores each angle: Impact, Confidence, Ease, each 1 to 10, and converges on one.

Storm always reads my brain before brainstorming, so I never get “build this thing you already built and killed last year.”

Rune - the silver scribe-witch, prompt master

“Show me the path. I’ll carve the rune.”

Rune is a silver-haired scribe in an autumn grove, carving glyphs into a runestone. Her job is to take Storm’s chosen path and turn it into a precise, machine-readable spec that Forge can execute. She picks the builder variant, defines success criteria, lists dependencies, and writes the actual prompt.

Rune is the still point between Storm’s open-armed possibility and Forge’s kinetic ship-mode. If Storm gave her twelve angles, she replies: “Pick three. I carve one.”

Forge - the cyber-mage, builder

“Hand me the rune. The forge is hot.”

Forge runs through dystopian code-cities with a keyboard as his hammer. He builds the thing. Five variants: Code for real repos, n8n for workflows, Next for apps, Script for CLI one-shots, and Doc for documents and decks. He logs every decision, every blocker, and every shortcut to a build.md file that is his honest field journal. Not a marketing log. The truth.

When the spec is unclear, Forge bounces back to Rune. He doesn’t guess. Bounces are healthy. They mean the spec needs another pass.

Echo - the haloed priestess, summarizer

“It’s done. Let me remember it for you.”

Echo wears a dark halo. Behind her: a vast ceremonial circle covered in script. The circle is the brain. The orbiting glyphs are projects already inscribed. The one forming in her palm is the project being recorded now.

Echo’s job is two passes. First, she writes a per-project summary.md that future-me in six months can use. Second, she enriches the brain across portfolio, interview bank, discovery-call pitches, blog ideas, stack inventory, insights, and the rest. Failed projects get entries too, because those are often the most valuable lessons.

Echo’s rule: append only. The brain grows monotonically. If something was wrong, append a correction with a date. Never edit history.

Hiru - the wolf, outward voice

“I walk beside you. Show me the road.”

Hiru is a giant wolf etched with white runes from every project I’ve carried through the forge. He handles every word that leaves me and reaches another person: cover letters, application emails, interview prep, pitches, negotiations.

Hiru has editorial freedom over framing and tone. He has zero agency over facts. The rule is: “The wolf would never lie about his pack.”If a job post asks for a skill I haven’t shipped, Hiru flags it to me. He never papers over it.

The Pipeline In Practice

The five agents are not parallel. They are a pipeline:

Storm  ->  Rune  ->  Forge  ->  Echo
                              ^
                          Hiru runs the outward perimeter

Storm goes wide. Rune narrows. Forge ships. Echo archives. Hiru speaks to the world. The handoffs are formal commands: /handoff rune, /handoff forge, /handoff echo, and so on. When something is broken, Forge bounces back to Rune. When the brain is needed, anyone can @echo.

This week the pipeline ran through several real builds. Let me walk through one of them.

One Real Run: The CV V5 Build

Pelozden RSS interviewed me for a Vibe Coder role at PHP 120,000 per month, hybrid in Clark Freeport Zone. The next step was an updated CV. The v4 resume positioned me as an e-commerce automation engineer. The role they’re considering reads me as a Vibe Coder. The CV needed to close that gap before the follow-up.

I opened the cathedral: /storm.

Stage 1: Storm

Storm read the brain first: portfolio master, stack inventory, insights, active opportunities. Then he ran the four-layer analysis on the CV update problem.

• Layer 1: rewrite v4 from scratch.
• Layer 2: surgical edits to v4.
• Layer 3: build the CV as a live Next.js artifact at /cv.
• Layer 4: hybrid: restructured PDF plus prominent portfolio link.

Layer 1 (full rewrite)        ICE: 7.3   Park It
Layer 2 (surgical edits)      ICE: 8.0   Strong fallback
Layer 3 (live web CV)         ICE: 5.7   Defer to phase 2
Layer 4 (hybrid)              ICE: 8.3   Build Now

Storm proposed a folder name: cv_v5_vibe_coder. I approved. Storm wrote brainstorm.md into that folder, sealed it, and handed to Rune.

Stage 2: Rune

Rune read Storm’s brainstorm and started carving. She picked the builder type: Forge:Doc. The deliverable was a document, not code or a workflow. She defined the success criteria: a PDF resume that leads with Vibe Coder identity, includes a new Personal AI Projects section featuring four builds with images, and ships in a state HR can drop into their file.

Her prompt.md was meticulous: per-section text, exact title line, reordered core competencies, four project cards, and screenshot placeholders sized for later swaps. Rune sealed the prompt and handed to Forge.

Stage 3: Forge

Forge confirmed the builder variant. He chose docx-js plus LibreOffice headless for PDF export, both inside the sandbox. He wrote cv_builder.js, ran it, validated the output XML, exported to PDF, and copied both files to the project folder.

He logged everything to build.md, including the blockers. The file got truncated mid-edit twice, a sandbox write-buffer issue. He bounced once, fixed the truncation by appending the missing tail, and continued. The whole thing took three retries and a scope addition: a leftover FastAPI mention that Rune had missed. Forge caught it on preview and removed it cleanly, logging the scope creep transparently.

The build log from that day is a real engineering log. Reading it back, I can see exactly what was decided, what was cut, and what almost broke.

Stage 4: Echo

Echo reads the brainstorm, the prompt, and the build log. She writes summary.md, adds the Vibe Coder positioning to the brain, logs the new role, and inscribes the resume work into the portfolio memory if I give the nod.

Stage 5: Hiru

While Echo archives, Hiru is drafting the interview follow-up with counter-terms. The role was framed at PHP 120,000 per month for 3 days on-site. I want to propose PHP 100,000 per month for 1 day on-site: a pay cut in exchange for less commute, since Tagaytay to Clark is 3 hours each way. Hiru wrote the email in my voice: no buzzwords, specific time math, and a flexibility clause for high-leverage in-person days.

What This Actually Does For Me

Five concrete benefits I see daily.

1. The brain prevents drift. Echo’s append-only memory means I never claim a project I haven’t shipped, never quote a number I haven’t verified, never propose a tool I haven’t used.
2. The pipeline forces clarity. Storm can’t hand to Rune without a chosen path. Rune can’t hand to Forge without success criteria. Forge can’t hand to Echo without a build log.
3. The voice rules stick. Hiru’s default is no buzzwords and specific numbers. Every outward thing I send has the same baseline cadence, even when I’m tired.
4. The bounces save me from bad work. Forge bouncing back to Rune is the team’s quality gate. When a spec doesn’t survive contact with reality, we know quickly.
5. The metaphor makes the work memorable. Every project has a Storm brainstorm, a Rune prompt, and a Forge build log. Three artifacts per project, each in a distinct voice.

The Architecture, Replicable

If you want to build something like this yourself, here is the minimum kit:

1. Five distinct system prompts. Each one has a name, an appearance reference, a voice, a job, files they read, files they write, and commands. Pick roles that do not overlap.
2. A shared brain directory. Mine is _brain/ with indexed markdown files. Echo and Hiru write to it; Storm, Rune, and Forge read from it.
3. A project folder convention. Every pipeline project gets brainstorm.md, prompt.md, build.md, actual artifacts, and summary.md.
4. A handoff protocol. Explicit commands: /handoff rune, /handoff forge, /handoff echo. Bounces too: /blocked returns the work up one stage with a reason.
5. A truth rule.Mine is “the wolf would never lie about his pack.” It binds every agent to the brain’s actual contents. Nothing invented, nothing claimed without backing.

Optional: give each agent a character image. I commissioned five fantasy illustrations. They are visual anchors for me when I switch personas, and they double as portfolio assets.

Where This Is Going

QoreX is the working method. The QoreNexus is where it lives. Together they are how I ship faster than a solo developer should be able to, without the drift that solo developers usually fall into.

I run QoreX every working day. I just used it to write this blog post: Storm framed the angle, Rune carved the outline, Forge typed the body, and Echo will close the inscription. I used it last week to deploy the yt-dlp microservice that powers a video automation pipeline. I’ll use it tomorrow to design the next slice of whatever project lands.

If you’ve been thinking about how to work with AI as a teammate instead of a tool, this is one shape that works. Steal the architecture. Adapt the voices. Build your own team. Send me what you make.

- Jeffrey
jeffreyquemuel.cloud