JARVIS CoWork Multi-Agent Dev Setup: 249 Agents in 180 Min

JARVIS CoWork Multi-Agent Dev Environment

JARVIS CoWork is an enterprise multi-agent development environment running 249 specialized AI agents through a hierarchical supervisor architecture. Each agent is a Claude Code subagent with its own context and tool access. The system ships with 570+ QA scripts and an MCP bridge to Claude Code. Teams using it report lead time dropping from 8 days to under 24 hours.

A mid-size SaaS company with 40 engineers runs 12 microservices. Each sprint, engineers lose 15-20 hours per person to context-switching between coding, reviewing, testing, debugging CI failures, and writing documentation. Lead time for changes averages 8 days. Change failure rate sits at 35%. The problem is not that engineers are slow. It is that coordination overhead between development, review, QA, security, and ops absorbs 40% of every sprint.

[ STAT ] The average enterprise change failure rate is 35%. Lead time for changes averages 8 days for mid-tier teams. — Google DORA 2025 Accelerate State of DevOps Report

JARVIS CoWork collapses this overhead by replacing inter-team handoffs with agent-to-agent delegation. A code change does not get thrown over the wall to QA — a QA specialist agent tests it in parallel. A security review does not wait for the security team — a security agent reviews every PR. The result is lead time dropping from 8 days to under 24 hours without adding headcount.

[TOOL: JARVIS CoWork Orchestrator (usejarvis.dev)] Runs a hierarchy of AI agents. The supervisor agent evaluates task type, decomposes into sub-tasks, and delegates to specialist agents with appropriate tool access. [TOOL: Claude Code via MCP Bridge] Used for deep codebase reasoning tasks. Agents delegate complex refactors to Claude Code, which returns verified diffs through the bidirectional MCP bridge. [TOOL: Python 3.10+] Agent runtime for most JARVIS components. Required for QA execution, orchestration, and the web dashboard. [TOOL: Docker] Container runtime for agent isolation. Each agent runs in its own container with scoped tool access.

The outcome: a full-stack feature that would take a 6-person team 2-3 sprints (3-4 weeks) ships in under 5 days. The 570+ QA scripts run in parallel across all affected services. Agents detect and repair CI failures autonomously.

For engineering directors (20-100 engineers): your team spends more time in meetings, reviews, and CI debugging than coding. JARVIS handles the review and testing pipeline. Your engineers focus on architecture.

For DevOps teams managing 10+ services: JARVIS automation agents handle deployment verification, rollback detection, and infrastructure-as-code audits. Your team stops firefighting.

For ISVs shipping on-prem or managed deployments: JARVIS runs 570+ QA scripts across all target environments in parallel. No more environment-specific bug surprises on release day.

1. Task Intake. Feature request or bug report enters via CLI or dashboard. Intake agent classifies by type, scope, urgency. Input: natural language. Output: structured task record.
2. Supervisor Delegation. Supervisor evaluates task and decides which specialist agents to engage. A backend API change routes to code-agent, test-agent, security-agent, and docs-agent in parallel. This is the agentic reasoning step.
3. Parallel Agent Execution. Each specialist agent receives its sub-task and tool context. Code-agent writes implementation. Test-agent generates tests. Security-agent scans. Docs-agent updates API docs. All simultaneous.
4. QA Script Execution. Orchestrator runs 570+ QA scripts against combined output: unit, integration, E2E, OWASP, performance. Input: agent outputs. Output: pass/fail report.
5. Self-Repair Loop. Failed QA triggers the repair agent. It reads the failure, diagnoses root cause, and either patches or reroutes to the original agent with fix instructions. Input: failure log. Output: corrected code.
6. MCP Bridge (Optional). For complex refactors, agents delegate to Claude Code through the bridge. Input: refactor spec. Output: Claude Code-verified diff.
7. Human Approval Gate. Consolidated review package presented. One-click approve or reject with notes.

180 minutes. That is the honest setup time for initial configuration. Tuning agent prompts, persona definitions, and QA scripts for your codebase takes 1-2 additional days.

JARVIS CoWork → Multi-agent orchestrator. Requires Docker. Runs a hierarchy of 249 agents with semantic-routed deployment. Configure pool sizing based on expected parallel workload. Claude Code → Deep reasoning via MCP bridge. Requires Claude Max. Each spawned subagent appears as a new session in Anthropic billing. Python 3.10+ → Agent runtime. Version compatibility across containers must be consistent. Docker → Container isolation. Use rootless Docker and read-only filesystems for production.

Gotcha: the 249 agents are not all active simultaneously. The system maintains an agent pool and spawns on demand. Misconfigured pool sizing causes agent starvation under heavy load, where tasks queue waiting for available agents. Also: the bidirectional MCP bridge means Claude Code sub-agents appear as new billing sessions. Token costs can surprise you if not monitored.

▸ Lead time for changes 8 days (DORA baseline) → under 24 hours ▸ Change failure rate 35% industry average → under 10% with 570+ QA scripts ▸ Engineer context-switch time 15-20 hrs/week → under 5 hrs/week ▸ Sprint feature throughput (6-person team) 4-6 stories → 12-18 stories ▸ Time to first ROI week 2-3 after tuning

1. Setup complexity: 180 min for initial config, 1-2 days for agent prompt tuning. Not a plug-and-play system.

2. Token costs at scale: 249 agents in parallel can cost $50-100/hour in heavy use. A 40-agent test run can burn $200. Set spending controls.

3. Agent file conflicts: multiple agents modifying overlapping files can cause cascade merge conflicts. Use file-locking or ownership-per-directory rules.

4. Self-repair over-correction: the fix loop can introduce new bugs. Set max 3 repair iterations and require human review for security or data layer changes.

5. (10 min) Install Docker and Python 3.10+. Verify both with docker --version and python3 --version.

6. (30 min) Deploy JARVIS CoWork orchestrator via Docker Compose. The official repo provides a docker-compose.yml with all agent containers.

7. (30 min) Authenticate Claude Code and configure the MCP bridge. Run claude mcp serve and verify JARVIS can connect.

8. (30 min) Run the built-in smoke test suite: jarvis test --smoke. This confirms all 249 agent profiles load and the supervisor can delegate a task.

Q: How many agents does JARVIS CoWork actually run? A: 249 specialized agents in the full configuration, but not all run simultaneously. The supervisor maintains an agent pool and spawns agents on demand. Default pool size is 20-30 concurrent agents. You configure pool sizing based on your available compute and expected parallel workload.

Q: How does JARVIS CoWork connect to Claude Code? A: Through a bidirectional MCP bridge. JARVIS agents delegate complex codebase reasoning tasks to Claude Code, which returns verified diffs. Claude Code can also spawn its own sub-agents, which appear as new sessions in Anthropic billing.

Q: What kind of QA scripts are included with JARVIS? A: 570+ scripts covering unit tests, integration tests, E2E browser tests, OWASP Top 10 security scans, performance benchmarks, and API contract tests. The scripts run in parallel across all affected services when triggered by the orchestrator.

Q: Do I need a GPU to run JARVIS CoWork? A: No. JARVIS CoWork uses Claude Code via API, not local inference. The Docker containers need CPU and RAM (16GB minimum recommended for the orchestrator + 10 concurrent agents). GPU is only needed if you run local models.

Q: How long does the self-repair loop take? A: Each repair iteration typically takes 3-5 minutes (agent reads failure, diagnoses root cause, implements fix, reruns QA). Default max is 3 iterations, so a full repair cycle takes 10-15 minutes. The supervisor logs the entire repair chain for human audit.

The hierarchical supervisor architecture is what separates JARVIS CoWork from simpler multi-agent setups. In a flat agent system, all agents share the same context and compete for the same resources. JARVIS uses a three-tier hierarchy: the top-level supervisor makes strategic decisions about task decomposition and agent allocation, mid-level specialist agents handle domain-specific work, and bottom-level execution agents run the actual tool calls. This prevents the coordination overhead that plagues flat multi-agent systems. The MCP bridge to Claude Code adds a fourth tier for tasks requiring deep codebase reasoning. When the code-agent encounters a refactor that spans 20+ files with complex dependency chains, it delegates to Claude Code through the bridge rather than attempting it with limited local context. The bridge is bidirectional — Claude Code can also spawn its own sub-agents through JARVIS infrastructure, creating a recursive hierarchy that scales to enterprise codebases.

The 570+ QA scripts that ship with JARVIS CoWork are organized into categories that mirror a production CI pipeline: unit tests verify individual functions, integration tests verify service interactions, E2E browser tests verify user flows, OWASP security scans check for common vulnerabilities, and performance benchmarks ensure latency and throughput thresholds are met. When the orchestrator detects a QA failure, it does not simply flag the issue for human review. The self-repair agent diagnoses the root cause by reading the failure log, tracing it to the specific code change, and either patching the output directly or re-routing to the original specialist agent with specific fix instructions. This self-repair capability is what makes the system truly autonomous rather than just an automated test runner. The repair agent has its own context window and tool access, so it can explore the codebase to understand the failure context before proposing a fix.