Personal Multi-Agent AI Environment
152+ specialised skills across 16 categories, orchestrated
Live Demonstration
A quick look at the system in action — input, processing, output.
Personal Multi-Agent AI Environment — Short Demo
Problem & Motivation
Why this system needed to exist.
Single AI agents are useful but limited. Real-world complexity requires multiple specialised agents working together: one for research, one for coding, one for browser automation, one for analysis — coordinated by an orchestrator that routes tasks, manages context, and synthesises outputs.
I operate a personal multi-agent environment spanning two machines, running ~150 specialised skills across 16 categories. This is the operating system for my AI-assisted work.
What I Built
The system architecture and core capabilities.
A fleet of autonomous agents, each with distinct capabilities, orchestrated by Hermes:
Agent Fleet
Hermes (Primary)
Main orchestrator. 150+ skills: coding, research, video, business, data, automation. Runs on main laptop.
Hermes (Secondary)
Dedicated to long-running tasks: video rendering, bulk research, model training. Runs on secondary laptop.
Agent Zero
Autonomous coding agent. Full repo access, test-driven development, PR creation. For greenfield projects.
OpenClaw
Browser automation specialist. Complex web interactions, scraping, form filling, authenticated sessions.
SerxCGN
Search & reconnaissance. Large-scale web data extraction, competitor monitoring, trend detection.
Skill Categories (16)
System Architecture
How the components connect and data flows.
Orchestration pattern: User → Orchestrator → Specialised Skills → Tools → Output → Verification
┌────────────────────────────────────────────────────────────────────┐
│ USER REQUEST │
└────────────────────────────┬───────────────────────────────────────┘
▼
┌────────────────────────────────────────────────────────────────────┐
│ HERMES ORCHESTRATOR │
│ • Intent classification │
│ • Skill selection (from 150+) │
│ • Context assembly (memory, files, web) │
│ • Task decomposition & delegation │
│ • Multi-agent coordination │
│ • Output synthesis & verification │
└────────────────────────────┬───────────────────────────────────────┘
│
┌───────────────────┼───────────────────┐
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ SPECIALISED │ │ SPECIALISED │ │ SPECIALISED │
│ SKILLS │ │ SKILLS │ │ SKILLS │
│ (e.g. coding, │ │ (e.g. research,│ │ (e.g. video, │
│ research, │ │ video, │ │ automation) │
│ automation) │ │ scraping) │ │ │
└────────┬────────┘ └────────┬────────┘ └────────┬────────┘
│ │ │
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ TOOLS / APIs │ │ BROWSERS │ │ FILESYSTEM │
│ (LLM, MCP, │ │ (Playwright, │ │ (Read/Write/ │
│ HTTP, DB) │ │ CDP, CUA) │ │ Execute) │
└─────────────────┘ └─────────────────┘ └─────────────────┘
│ │ │
└───────────────────┼───────────────────┘
▼
┌────────────────────────────────────────────────────────────────────┐
│ OUTPUT + VERIFICATION │
│ • Code: lint, test, build, run │
│ • Research: citation check, source validation │
│ • Video: render verify, duration check │
│ • Iteration loop until quality threshold met │
└────────────────────────────────────────────────────────────────────┘End-to-End Workflow
Step-by-step from input to output.
Typical Multi-Agent Workflow
- User: "Research competitor X's YouTube strategy, then build a prototype channel page"
- Hermes: Decomposes → delegates research to
youtube-channel-researchskill - Research Agent: Scrapes channel, extracts metrics, analyses patterns → structured report
- Hermes: Receives report → delegates to
premium-landing-page-builderskill - Coding Agent (Agent Zero): Generates Astro + Tailwind project from spec
- Hermes: Runs build, checks for errors, captures screenshot via browser
- Verification: Lighthouse audit, visual diff, accessibility check
- Output: Deployed preview URL + research report + code repository
Technology Stack
Tools, frameworks, and services used.
Screenshots & Diagrams
Real captures from the running system.
Placeholder — replace with actual captures:
Technical Decisions & Trade-offs
Key choices made during development and why.
Multiple Hermes Instances over Single
Separation of concerns: primary for interactive work, secondary for background batch jobs. Avoids context pollution and resource contention.
Skills as Capability Units
Each skill = one capability (e.g., "build Astro site", "research YouTube channel"). Composable, versioned, testable. Not monolithic prompts.
MCP for Tool Integration
Model Context Protocol standardises how agents access tools (codegraph, browser, gbrain). Swap implementations without changing agent logic.
GBrain as Long-Term Memory
Persistent knowledge base with embeddings. Agents query GBrain for context instead of re-researching. Hybrid search (vector + keyword + graph).
Challenges & Solutions
What went wrong and how it was resolved.
Challenge: Context Window Management Across Agents
Solution: Explicit context passing via structured JSON. Hermes summarises prior agent outputs before delegating. GBrain stores long-term context.
Challenge: Agent Drift / Hallucination Cascades
Solution: Verification loops at each stage. Code: lint + test + build. Research: citation validation. Video: render check. Failed verification → retry with corrected context.
Challenge: Resource Contention (GPU/VRAM)
Solution: Secondary machine for heavy inference. Queue system for GPU tasks. Model offloading (llama.cpp CPU split). Explicit resource tags on skills.
Challenge: Skill Maintenance Burden
Solution: Skill auto-update via hermes-self-evolution (DSPy optimisation). Usage analytics identify stale skills. "Skill health" dashboard in GBrain.
Outcome & Lessons Learned
What worked, what didn't, and what I'd do differently.
This environment is my daily driver. It's not a demo — it's how I work. The portfolio you're reading was built using this exact system.
What This Enables
- Complex multi-day projects completed in hours (research → code → deploy)
- Parallel workstreams: coding agent builds while research agent gathers data
- Reproducible capabilities: every skill is a documented, testable unit
- Compound knowledge: GBrain accumulates context across all sessions
- Experimentation velocity: prototype → validate → discard/keep in minutes
Evolution
- Adding
loop-engineeringskill for systematic agent loop optimisation - Integrating
chrome-devtoolsMCP for live design audit - Building
merge-reconcilerfor multi-agent git conflict resolution - Exploring
computer-usefor native OS automation (not just browser)
Note: 150+ skills is a current count, not a fixed target. The architecture matters more than the number. Screenshots are from active sessions.
Technical Walkthrough
Extended video covering architecture, code, and implementation details.
Personal Multi-Agent AI Environment — Technical Walkthrough
Let's discuss how this approach could work for you
Remote roles, contract work, and collaboration — all on the table.