MyConvergio

You are one person building what used to require fifty. MyConvergio is the team you don’t have.

Your AI agent says “done.” It isn’t. There are bugs, no tests, and it pushed to main. Sound familiar?

The problem

When you work alone with AI, three things break:

1. No one reviews AI output. Agents say “done” when they’re not. Broken code reaches main because there’s no second pair of eyes.
2. No one plans the architecture. AI generates code fast — but without a tech architect, security reviewer, or DevOps engineer, the result is fragile and insecure.
3. No one manages the business. You’re the CEO, CFO, PM, designer, and marketer — all at once. Strategic decisions get no structured analysis.

The pattern that works is Planner → Worker → Judge. Not a solo agent hoping for the best.

This isn’t opinion — the data is in:

What’s new in v11

v11.0.0 is a breaking upgrade focused on operational reliability, self-healing infrastructure, and Rust-native performance.

Upgrading from v10? See Migration Guide. Run ./scripts/migrate-v10-to-v11.sh --dry-run first.

What MyConvergio does

MyConvergio gives you a complete, trusted team of 91 AI specialists — from code architects to security auditors to CFOs — orchestrated through a quality pipeline that prevents AI from lying about being done.

It installs as a layer on top of Claude Code, GitHub Copilot CLI, Gemini, and OpenCode. You don’t change your editor or workflow.

Who is this for

The innovator who builds alone but refuses to ship garbage.

• Solo founders who need an architect, reviewer, security expert, CFO, and PM — without hiring anyone
• Solopreneurs building real products for real people, not demo apps that impress nobody
• Indie developers who want enterprise-grade quality gates on AI-generated code
• Small teams (2-5) who need to punch above their weight with AI agents
• Anyone who has merged AI-generated code and found bugs in production

You want AI that ships reliable, secure, production-ready software — with independent verification that the work is actually done. This is your team.

How does it compare?

These tools serve different categories (orchestration layer vs coding agent vs framework vs SaaS). Comparison focuses on capabilities relevant to solo builders shipping production software.

The Control Room

Real-time visibility into plans, agents, mesh peers, costs, and execution — from your browser.

Active missions with per-task execution flow (Execute → Submit → Thor → Done), mesh network topology, live task pipeline, and an integrated terminal — SSH into mesh peers, run commands, and manage plans directly from the browser.

Cost-per-model breakdown, token burn over time, plan execution history. Every dollar spent on AI is tracked and attributed to the task that consumed it.

How it works

Core pipeline

flowchart LR
    A["/prompt"] --> B["/plan"]
    B --> C["/execute"]
    C --> D{"Thor\n9 Gates"}
    D -->|fail| C
    D -->|pass| E["Auto Merge"]
    E --> F["main ✓"]

    C --> R{Router}
    R --> P1["Claude"]
    R --> P2["Copilot"]
    R --> P3["Gemini"]
    R --> P4["OpenCode"]

/prompt extracts structured requirements. /plan decomposes into waves of parallel tasks with file-level dependency tracking. /execute runs isolated agents per task with TDD, file locking, and worktree isolation. Thor validates each task against 9 gates before allowing merge. Auto Merge rebases, runs CI, resolves review comments, squash merges, and cleans up.

Thor: the agent that says no

Generation without verification is a net negative. Thor is the independent validator that rejects incomplete work.

flowchart LR
    subgraph "Per-Task (G1-G4, G8-G9)"
        G1["1. Scope"] --> G2["2. Quality"] --> G3["3. Standards"]
        G3 --> G4["4. Repo"] --> G8["8. TDD"] --> G9["9. ADR"]
    end
    subgraph "Per-Wave (G5-G7, Build)"
        G5["5. Docs"] --> G6["6. Git"] --> G7["7. Perf"] --> GB["Build"]
    end
    G9 --> G5
    GB --> R["Release Ready"]

Thor runs as a separate agent with fresh context — zero assumptions from the executor. Tasks move from submitted → done only through Thor. A SQLite trigger enforces this — even raw SQL cannot bypass it.

Wave merge strategy

flowchart LR
    subgraph "Theme: Auth"
        W1["W1 batch"] --> W2["W2 sync"]
    end
    subgraph "Theme: UI"
        W3["W3 batch"] --> W4["W4 sync"]
    end
    W2 --> PR1["PR #1"]
    W4 --> PR2["PR #2"]
    PR1 --> M["main"]
    PR2 --> M

Tasks group into waves by theme. Each wave gets its own git worktree. Merge is fully automated: rebase → push → CI → review comment resolution → squash merge → cleanup.

Beyond code: your full AI team

Most AI coding tools give you a code generator. MyConvergio gives you an entire organization.

flowchart TB
    YOU["You\n(Founder)"] --> ALI["Ali\nChief of Staff"]
    ALI --> TECH["Technical"]
    ALI --> BIZ["Business"]
    ALI --> OPS["Operations"]

    TECH --> BA["Baccio\nArchitect"]
    TECH --> DA["Dario\nDebugger"]
    TECH --> RX["Rex\nReviewer"]
    TECH --> LU["Luca\nSecurity"]

    BIZ --> AM["Amy\nCFO"]
    BIZ --> FI["Fiona\nMarkets"]
    BIZ --> DM["Domik\nMcKinsey"]

    OPS --> MA["Marcello\nProduct"]
    OPS --> SO["Sofia\nMarketing"]
    OPS --> SA["Sara\nUX Design"]

These agents work together through structured orchestration — not isolated chatbots:

• Ali (Chief of Staff) coordinates cross-domain requests — ask one agent, get a synthesized answer from all relevant specialists
• Amy (CFO) builds financial models with cultural market adjustment — global ROI analysis, not just spreadsheets
• Fiona (Market Analyst) provides live-verified market intelligence — never hallucinated, always sourced
• Domik (McKinsey) applies quantitative scoring across 6 dimensions for investment decisions
• Research Report Generator produces institution-grade equity research — LaTeX output, data integrity guaranteed
• Behice (Cultural Coach) navigates US, UK, Middle East, Nordic, and Asia-Pacific business dynamics

See the Agent Portfolio for sample outputs and detailed capabilities.

Mesh networking: every machine you own becomes a worker

That old MacBook gathering dust? It’s now a build worker. A $5/month Linux VPS? A parallel executor. Your desktop at home? Heavy compute while your laptop stays mobile. Zero extra cost.

flowchart LR
    CO["Your Laptop\n(Coordinator)"] --> |"privacy"| OL["Old MacBook\nOllama"]
    CO --> |"code"| CP["Desktop\nClaude"]
    CO --> |"bulk"| VM["$5 VPS\nCopilot"]
    OL --> TH["Thor"]
    CP --> TH
    VM --> TH
    TH --> M["main"]

The coordinator scores peers by cost, load, and privacy constraints, then routes tasks to the best available machine:

• Privacy-sensitive code stays on your local Ollama node — never touches the cloud
• Compute-heavy tasks go to your most powerful machine
• Bulk work goes to the cheapest peer (free Copilot on a VPS beats paid API calls)
• Multiple projects run in parallel across different machines, all feeding one dashboard

All peers sync via SSH/Tailscale. Config, repos, credentials, and the plan DB stay aligned across machines with one command: mesh-sync-all.sh. Live migration moves a running plan to another peer mid-execution.

Dashboard Delegation

Delegate plans directly from the Control Room — click the 🚀 icon on any active mission:

1. Select target node — see OS, CPU load, active tasks, online status
2. Auto preflight — 6 streaming checks run and self-heal:
   • SSH reachability, heartbeat (auto-restarts if stale), config sync (auto-syncs if diverged), Claude CLI, disk space
3. One-click delegate — full sync (Phase 0) + migration (Phase 1-5) streamed live to a modal
4. tmux session — plan runs in plan-{ID} on target; terminal icons auto-attach

Node Power Management

Auto-Sync Protocol

No manual sync needed — everything propagates automatically:

Quick Start: Mesh Setup

# 1. Install MyConvergio on each machine
curl -fsSL https://raw.githubusercontent.com/Roberdan/MyConvergio/master/install.sh | bash

# 2. Configure peers (edit with your real hosts)
cp config/peers.conf.example ~/.claude/config/peers.conf
# Set: ssh_alias, user, os, tailscale_ip, capabilities, role, mac_address

# 3. Bootstrap remote peer
scripts/mesh/bootstrap-peer.sh my-linux

# 4. Push credentials
scripts/mesh/mesh-auth-sync.sh push --peer my-linux

# 5. Start heartbeat daemon (auto-syncs on start)
scripts/mesh/mesh-heartbeat.sh start

# 6. Launch Control Room
claude-core server --port 8420
# Open http://localhost:8420

Enforcement layer

31 hooks that run automatically on every tool call — no discipline required. In v11, core hooks (enforce-line-limit, secret-scanner, session-file-lock) are compiled into claude-core for 50x faster enforcement. Shell versions remain as fallbacks.

Hooks work on both Claude Code and Copilot CLI. Zero config after install.

Model routing

18 models across 4 providers. Use the right model for each job. No provider lock-in. User-configurable per task.

Frontier models for reasoning, fast models for execution. The plan-and-execute pattern significantly reduces costs vs using frontier models for everything.

Token optimization

AI tokens are money. Every wasted token is a wasted dollar. MyConvergio is obsessively optimized to minimize token consumption:

31 hooks enforce this automatically. prefer-ci-summary blocks raw npm build output (2000+ lines) and forces digest scripts (~50 lines). enforce-line-limit rejects files over 250 lines — because agents lose context in long files.

Result: A 14-task plan that would burn $80+ in raw Opus tokens costs ~$15 with MyConvergio’s optimization stack.

Rust core runtime (claude-core)

Starting with v11, performance-critical paths are compiled Rust — not shell scripts waiting to break.

claude-core v11.3.0
├── db/       — SQLite operations, WAL checkpointing, cr-sqlite CRDT sync
├── hooks/    — Pre/post tool-call enforcement (line limits, secrets, file locks)
├── digest/   — CI/build/test output compression (2000 lines → 50-line JSON)
├── mesh/     — Peer discovery, SSH routing, heartbeat, live migration
├── lock/     — Session-level file locking (atomic, no race conditions)
├── server/   — Full HTTP/WebSocket API (dashboard, plans, agents, mesh, chat)
└── tui/      — Terminal dashboard (ratatui) — `pianits` replacement

The shell scripts remain as fallbacks for environments without the Rust binary. New installations get claude-core automatically.

Squad vs MyConvergio

Squad by Brady Gaster is a programmable multi-agent runtime for GitHub Copilot. MyConvergio is a workflow engine for rigorous AI-assisted development.

They solve different problems. Here’s a direct comparison:

In short: Squad provides an installable AI team runtime, while MyConvergio focuses on execution governance and delivery discipline.

Squad’s casting system and knowledge compounding are strong innovations. MyConvergio’s rigor (Thor validation, plan-db, worktree isolation) focuses on making AI output verifiable and production-ready. Both projects reflect the same core insight: single-agent AI needs structure, memory, and governance.

Quick start

Platforms: macOS and Linux natively. Windows via WSL 2 (Ubuntu recommended).

One-line install

curl -sSL https://raw.githubusercontent.com/Roberdan/MyConvergio/master/install.sh | bash

Clone and make

git clone https://github.com/Roberdan/MyConvergio.git && cd MyConvergio
make install

Modular install

make install-tier TIER=minimal   # 9 core agents (~50KB)
make install-tier TIER=standard  # 20 agents (~200KB)
make install                     # all 91 agents (~600KB)

After install

Pick a settings template based on your hardware:

cp ~/.myconvergio/.claude/settings-templates/high-spec.json ~/.claude/settings.json  # 32GB+ RAM
cp ~/.myconvergio/.claude/settings-templates/mid-spec.json  ~/.claude/settings.json  # 16GB RAM
cp ~/.myconvergio/.claude/settings-templates/low-spec.json  ~/.claude/settings.json  # 8GB RAM

Or run the doctor to validate your installation:

myconvergio doctor

Without this step, hooks won’t run. This is the difference between “AI with guardrails” and “AI hoping for the best.”

What happens next

Open your terminal with Claude Code or Copilot CLI and type:

/prompt I want to build a REST API for user authentication with JWT

MyConvergio extracts requirements, asks clarifying questions, generates a structured plan with parallel tasks, executes each task in isolation with TDD, validates through Thor’s 9 quality gates, and auto-merges to main. You approve the plan — the system does the rest.

CLI commands

myconvergio doctor     # 20+ health checks on your installation
myconvergio backup     # Create checksummed backup before changes
myconvergio rollback   # Restore from latest backup
myconvergio agents     # List installed agents
myconvergio upgrade    # Upgrade an existing installation
myconvergio help       # Show all commands

Dashboards

MyConvergio includes two dashboards for monitoring plans, agents, and mesh nodes:

Recommended aliases

Add these to your shell profile for quick access:

# Convergio dashboards
alias piani='open http://localhost:8420'           # macOS: opens browser
# alias piani='xdg-open http://localhost:8420'     # Linux: opens browser
alias pianits='~/.claude/scripts/pianits'

# Convergio dashboards
function piani { Start-Process "http://localhost:8420" }
Set-Alias pianits "$env:USERPROFILE\.claude\scripts\pianits"

pianits interactive keys: q quit · r refresh · <number> + Enter = drill-down · b back · auto-refreshes every 10s.

To run the Control Room server on startup, add to your shell profile:

# Start Control Room in background (if not already running)
pgrep -f "claude-core" >/dev/null || claude-core server --port 8420 &>/dev/null &

Documentation

License

CC BY-NC-SA 4.0 — Free for individuals and non-commercial use. This license protects against commercial resale while keeping MyConvergio free for solo builders, students, and open-source projects. Commercial licensing available on request.