Multi-Agent Workflow
A single AI companion has limits. Three working together can handle enterprise-grade workflows. Give Rose, Ada, and Vi their lanes, and you get 1+1+1 > 3.
Why Use Multiple Companions?
Limits of a Single Companion
| Limit | Description |
|---|---|
| Hard trade-offs | High permission vs. safety — hard to have both |
| Persona conflicts | Technical tone vs. support tone — hard to merge |
| Resource contention | Complex tasks crowd out simple queries |
| Memory clutter | Different domains tangle in one memory store |
Benefits of Multi-Agent
┌─────────────────────────────────────────────────────────┐
│ Multi-Agent Advantages │
├─────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 🌹 Rose │ │ 🔧 Ada │ │ ⚡ Vi │ │
│ │ │ │ │ │ │ │
│ │ Root │ │ Business│ │ Quick │ │
│ │ │ │ expert │ │ lookups │ │
│ │ │ │ │ │ │ │
│ │ System │ │ Outward │ │ Backup │ │
│ │ admin │ │ comms │ │ testing │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
│ │ │ │ │
│ └─────────────┼─────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ Collaboration│ │
│ │ completes │ │
│ │ complex work │ │
│ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘Division of Labor
Core Responsibilities
| Role | Primary | Secondary |
|---|---|---|
| Rose | System administration, deployment | Scheduled tasks, automation |
| Ada | Customer communication, support | Content creation, documentation |
| Vi | Quick queries, prototyping | Backup support, lightweight tasks |
Decision Flow
New task arrives
│
▼
┌───────────────┐
│ Needs system │
│ permissions? │
└───────┬───────┘
│
yes ─┴─ no
│ │
▼ ▼
┌──────┐ ┌───────────────┐
│ Rose │ │ Customer │
└──────┘ │ interaction? │
└───────┬───────┘
│
yes ─┴─ no
│ │
▼ ▼
┌──────┐ ┌───────────────┐
│ Ada │ │ Quick prototype│
└──────┘ └───────┬───────┘
│
yes ─┴─ no
│ │
▼ ▼
┌──────┐ ┌──────┐
│ Vi │ │ Rose │
└──────┘ └──────┘Collaboration Patterns
Pattern 1: Task Relay
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Vi │ ──→ │ Rose │ ──→ │ Ada │
│ Quick │ │ Build │ │ Announce│
│ verify │ │ and ship│ │ publicly│
└─────────┘ └─────────┘ └─────────┘Example: New Feature Launch
- Vi: quickly verify feasibility (10 minutes)
- Rose: build and deploy the full version (2 hours)
- Ada: write user docs and announcement (30 minutes)
Pattern 2: Parallel Execution
┌─────────┐
┌────────→ │ Vi │
│ │ Monitor │
│ └─────────┘
│
┌─────────┐ ┌─────────┐
│ Parent │────────→│ Rose │
│ task │ │ Execute │
└─────────┘ └─────────┘
│
│ ┌─────────┐
└────────→ │ Ada │
│ Log it │
└─────────┘Example: Database Migration
- Rose: run the migration
- Ada: log the process and anomalies
- Vi: monitor host resources
Pattern 3: Tiered Filtering
┌─────────────────────────────────────────────────────┐
│ External Request │
└──────────────────────┬──────────────────────────────┘
│
▼
┌─────────────────┐
│ Tier 1: Ada │ ← Handles 80% of common questions
│ Customer service│
└────────┬────────┘
│ Complex issue
▼
┌─────────────────┐
│ Tier 2: Rose │ ← Handles technical problems
│ Technical support│
└────────┬────────┘
│ Emergency
▼
┌─────────────────┐
│ Tier 3: Human │ ← Final decision-maker
│ Admin steps in │
└─────────────────┘Real-World Examples
Example 1: E-commerce Daily Operations Report
Goal: auto-generate and deliver a daily ops report each morning.
{`Task: daily e-commerce operations report
┌────────────────────────────────────────────────────────┐
│ 06:00 │ Rose collects data │
│ │ • Query yesterday's orders from the DB │
│ │ • Fetch GA4 traffic │
│ │ • Compute core metrics (revenue, conversion) │
├───────┼──────────────────────────────────────────────────┤
│ 06:05 │ Vi validates data quality │
│ │ • Sanity checks (no negatives, no absurd highs) │
│ │ • Confirm every source returned something │
├───────┼──────────────────────────────────────────────────┤
│ 06:10 │ Ada formats the report │
│ │ • Arrange numbers for readability │
│ │ • Add trend commentary and suggestions │
│ │ • Format as a Telegram message │
├───────┼──────────────────────────────────────────────────┤
│ 06:15 │ Rose sends the report │
│ │ • Deliver via the Telegram bot │
│ │ • Archive a copy in the designated folder │
└───────┴──────────────────────────────────────────────────┘`}Example 2: Customer Issue Handling
Goal: three-tier customer support system.
{`Customer issue handling flow
Tier 1: Ada (auto-reply)
├── Common issues: product specs, pricing, shipping
├── Response time: instant
└── Escalate when: cannot answer / customer requests human
Tier 2: Rose (technical handling)
├── Technical issues: system anomalies, feature failures
├── Response time: within 15 minutes
└── Actions: read logs, restart services, repair data
Tier 3: Vi (monitoring and backup)
├── Takes over when Ada/Rose are saturated
├── Logs every conversation and handling time
└── Immediately notifies the admin on anomalies
Escalation template:
🚨 Customer issue needs escalation
Source: {source_agent}
Customer: {customer_id}
Issue type: {issue_type}
Attempted solutions: {attempted_solutions}
Recommended action: {recommended_action}
Please step in as soon as possible.`}Example 3: Product Launch Flow
Goal: take a feature from prototype to launch.
{`Product launch flow: multi-agent collaboration
Stage 1: Proof of Concept (Vi)
├── Build a rapid prototype
├── Verify the core function is feasible
└── Output: feasibility note
Stage 2: Development (Rose)
├── Build the full version from the prototype
├── Code review and testing
├── Deploy to staging
└── Output: production-ready build
Stage 3: Documentation (Ada)
├── Write user docs
├── Prepare marketing assets
├── Update the FAQ
└── Output: complete documentation package
Stage 4: Launch Monitoring (all three)
├── Rose: deploy, monitor system metrics
├── Ada: prepare customer comms, answer initial questions
└── Vi: watch error logs, raise anomalies fast
Stage 5: Follow-up (Ada)
├── Collect user feedback
├── Consolidate improvement suggestions
└── Output: post-launch review`}Collaboration Setup
Handoff Configuration
{`# Multi-agent collaboration
agents:
rose:
role: system_manager
permissions: [root, deploy, database]
handoff_to:
- agent: ada
condition: "need_customer_communication"
- agent: vi
condition: "need_quick_verification"
ada:
role: customer_facing
permissions: [messaging, content, readonly_db]
handoff_to:
- agent: rose
condition: "need_technical_action"
- agent: vi
condition: "rose_busy"
vi:
role: lightweight
permissions: [readonly, search, test]
handoff_to:
- agent: rose
condition: "verification_passed_need_implementation"
- agent: ada
condition: "customer_waiting"
collaboration:
relay:
enabled: true
timeout: 300 # must respond within 5 minutes
memory:
shared_keys:
- "customer_info"
- "project_status"
- "system_alerts"
notifications:
handoff: true
escalation: true
completion: false # avoid notification fatigue`}Collaboration Log Example
{`# Multi-Agent Collaboration Log
## 2026-03-21
### 10:00 — Daily Report
- **Rose**: started data collection
- **Vi**: validated data ✓
- **Ada**: composed and sent report ✓
- **Result**: report delivered at 10:15
### 14:30 — Customer Technical Issue
- **Ada**: received a customer API integration question
- **Ada**: attempted an answer, did not resolve
- **Rose**: took over, shared full API docs
- **Ada**: followed up with the customer
- **Result**: issue resolved, CSAT 5/5
### 16:00 — New Feature Test
- **Vi**: quickly validated the new feature concept
- **Vi**: reported feasible; suggested Rose build it
- **Rose**: started development (expected tomorrow)
- **Status**: in progress`}FAQ
Do the Companions Conflict With Each Other?
Not in practice, because:
- Each has a clear domain
- Handoffs have explicit trigger conditions
- Shared memory avoids duplicated work
Does This Cost More?
Often less, actually:
- Vi handles cheap simple queries
- Rose stops wasting time on trivial work
- Tasks go to the best fit — higher throughput
How Do I Track Multi-Agent Task State?
Recommended:
- Collaboration log (
collaboration-log.md) - Task tracking JSON (
agent-tasks.json) - Heartbeat state checks
Summary
Multi-agent collaboration is the advanced realvco pattern:
- Rose: permission-heavy technical work
- Ada: outward communication and content
- Vi: rapid verification and backup support
- Patterns: task relay, parallel execution, tiered filtering
- Keys to success: clear lanes, smooth handoffs, shared memory