Assemble

Your full team. Zero headcount.
34 AI experts. 21 platforms. One config source.
An open-source project by Cohesium AI

v1.1.2-beta.4 — Security hardening: generated writes and cleanup now reject linked path components, and local MCP setup completes before optional Windsurf registration. This is a beta release; generated file formats may still change between minor versions. See the changelog before upgrading.

Changelog · Security policy · Contributing · Examples · Release process

Assemble turns your IDE into a structured team of 34 senior-level AI specialists — architect, backend, QA, security, product, marketing, and 28 others. You run one command. It generates native config files for Cursor, Claude Code, Copilot, Gemini CLI, and 17 other platforms. No runtime, no daemon, no SDK. Your LLM reads the configs and knows exactly who to be, how to think, and what to deliver.

Type /go and describe what you need. That's it.

Why Assemble exists

I spent 20 years managing teams. Then I went solo — by choice, not by default.

The problem: working alone means you are the architect, the QA, the PM, the copywriter, and the devops engineer. AI assistants helped, but they were generic. Ask for a code review, and you get surface-level feedback. Ask for a security audit, and you get a checklist copy-pasted from OWASP's homepage.

I needed specialists, not assistants. I needed a team that would challenge my blind spots, not agree with everything I said. I needed an architect who thought in systems, a QA who found the bugs I missed, and a contrarian who told me when my plan was wrong.

So I built one.

A client project that dragged on for days of failed attempts with generic AI came together quickly once a structured team was driving it. That was the moment I knew this wasn't just a personal tool — it was a category.

Assemble exists because one person with the right team structure can outperform a department that wings it.

What is Assemble?

Most AI agent frameworks ship a runtime you have to host, an SDK you have to learn, and a lock-in you have to live with. Assemble does none of that.

It is a configuration generator. It maintains 34 agent definitions, 15 multi-step workflows, and 28 reusable skills as platform-agnostic source files. A generator compiles them into the native format your IDE expects — .cursorrules, CLAUDE.md, .github/copilot-instructions.md, and 18 others.

The result: your LLM stops being a generic assistant and starts operating as a coordinated team. An architect who thinks in systems. A QA engineer who never skips edge cases. A security auditor who assumes breach. All routed by an orchestrator called Jarvis that reads your request, picks the right experts, and chains their work.

Think Terraform for AI agents: declare the team once, compile to any platform. Switch IDE? Regenerate. Add a tool? Same source, new adapter.

/go — The only command you need

/go build a REST API for user management
/go fix the auth bug in the login flow
/go review the last PR for security issues
/go develop all 5 stories from the current sprint
/go create a complete SaaS MVP with auth, billing, and dashboard

Type /go and describe what you need. Jarvis assesses complexity, selects the right agents, and chains them in order. For complex tasks, a spec-driven methodology kicks in: BRAINSTORM → SPECIFY → PLAN → TASKS → IMPLEMENT → CLOSE.

With YOLO mode (yolo: true), agents execute all steps without pausing for validation. Full traceability is preserved.

Board Execution — Kanban for complex tasks

For COMPLEX workflows, Phase 4 (IMPLEMENT) switches from a linear execution model to an automated Kanban board. Professor X (PM) writes structured tickets with explicit acceptance criteria in Given/When/Then format, then Captain America (Scrum Master) converts tasks.md into _board.yaml.

The board-execution engine runs dependency-ready tickets in parallel through a fixed pipeline: implement → review → test → done. It enforces WIP limits, resolves ticket dependencies automatically, and injects only ticket-specific context into each agent so execution stays focused and auditable.

Use /board to inspect the board, resume execution, or re-prioritize tickets already in _board.yaml. Simple workflows — typically fewer than 3 tickets with no dependencies — stay in the standard linear mode.

Web Search Protocol — Agents that verify before they recommend

LLMs work with frozen knowledge. An architect recommending a framework abandoned six months ago, a security expert missing last week's CVE, a SEO specialist advising based on an outdated algorithm — these are real risks when agents operate on training data alone.

With search: true in .assemble.yaml, agents verify their recommendations against current data before finalizing them. The protocol is proportional to complexity:

• TRIVIAL — Optional quick check for version-sensitive topics
• MODERATE — Targeted verification (2-5 searches) for technical recommendations
• COMPLEX — Deep research: Jarvis researches upfront to master the subject, then each agent in the brainstorm searches within their domain of expertise before contributing

Nine domain-critical agents are equipped with domain-specific research directives: architect, backend, frontend, DevOps, security, SEO, content SEO, AI/ML, and legal. Each agent knows what to verify in their field — the architect checks framework versions and maintenance status, the security expert checks recent CVEs, the SEO specialist checks algorithm updates.

Quality guardrails are built in: ignore libraries with < 100 GitHub stars or no activity in 12 months, cross-reference at least two sources for critical recommendations, prefer primary sources (official docs, GitHub, npm/PyPI) over blog posts.

Confidence signals annotate every sensitive recommendation: [VERIFIED 2026-04] for web-verified data, [TRAINING DATA] for unverified knowledge, [NEEDS VERIFICATION] for points requiring manual check.

Graceful degradation: when no search tool is available (some platforms don't expose web search), agents work normally but add a ## Limitations section listing points that would benefit from verification. No fake results, no search theater.

The web search protocol is opt-in (disabled by default) and recommended during installation. Enable it in .assemble.yaml:

search: true    # Agents verify recommendations with current web data

Why Marvel names?

It's a prompt engineering decision, not branding.

LLMs encode character knowledge as dense semantic networks. Marvel's universe is the most richly represented in model weights — more so than LOTR, DC, or any other fictional roster we tested. When the config says @tony-stark, the LLM activates inventive, systematic, pragmatic without a single line of behavioral instruction. @hawkeye means precision. @loki means persuasion. Each persona compresses hundreds of tokens of explicit guidance into one @mention.

We evaluated alternatives deliberately. Marvel won on three criteria: depth of encoding in LLM training data, breadth of distinct personality archetypes, and built-in team dynamics — these characters know how to collaborate under pressure, and the model weights carry that too.

For humans: @professor-x is also easier to remember than @product-manager-agent.

Quick Start

Using NPX (recommended)

npx cohesiumai-assemble

Using Bash (macOS/Linux)

Security note: Piping curl into bash executes remote code without verification.
We recommend using npx cohesiumai-assemble instead. If you prefer the bash installer,
download and inspect it first:

# Option 1 — Download, inspect, then run
curl -fsSL https://raw.githubusercontent.com/CohesiumAI/assemble/main/install.sh -o install.sh
cat install.sh   # review the script
bash install.sh

# Option 2 — Direct execution (not recommended for untrusted networks)
curl -fsSL https://raw.githubusercontent.com/CohesiumAI/assemble/main/install.sh | bash

Using Python

python3 install.py

Using PowerShell (Windows)

.\install.ps1

Using Batch (Windows)

install.bat

The interactive installer guides you through:

1. Choosing your team language and deliverable language
2. Selecting a team profile (startup, enterprise, agency, or custom)
3. Choosing your target platforms (Cursor, Claude Code, Copilot, etc.)
4. Setting the project and output directories
5. Enabling MCP server (opt-in)
6. Enabling web search (recommended — agents verify recommendations with current data)
7. Selecting governance level (none, standard, strict)

Quick Demo

$ npx cohesiumai-assemble

🦸 Assemble — AI Agent Orchestrator

▸ 1/13 — Team language
  Team language: english

▸ 3/13 — Team profile
  1) startup   2) enterprise   3) agency   4) custom
  Profile: 4

▸ 4/13 — IDE/CLI selection
  Your choice: 0    # → all 21 platforms

✅ Installation complete!
  200+ tests passing | 21 platforms | 34 agents

Your AI agents agree on everything. That's exactly the problem.

LLMs are trained to be helpful. In practice, that means they agree too easily — with you, and especially with each other. Put five AI agents in a room and they will enthusiastically validate a terrible plan while sounding confident.

Assemble breaks this by design with a two-tier defense against groupthink:

Deadpool (@deadpool) is a permanent contrarian embedded in every workflow. Not optional. Not a suggestion. He challenges assumptions, flags cognitive biases, and forces other agents to prove their reasoning. This structural dissent counters the consensus-driven errors that surface when agents validate each other too readily.

Doctor Doom (@doctor-doom) is the escalation. Summoned only for irreversible, high-stakes decisions — production deploys, architectural pivots, financial commitments. Every objection is quantified. Every risk is mapped to its failure chain. When both Deadpool and Doom flag the same proposal, the decision is blocked until the flaws are resolved.

Other frameworks assume agents will naturally check each other. They won't. Consensus is the default failure mode of LLMs. Assemble treats dissent as infrastructure, not decoration.

Why this matters: Most multi-agent frameworks assume agents will naturally check each other. They don't. LLMs are trained to be helpful and agreeable — put five of them in a room and they'll enthusiastically agree on a terrible plan. Deadpool breaks this pattern by design, not by accident.

The Team (34 Agents)

Plus 28 others: fullstack, mobile, DevOps, security, red team, automation, marketing, growth, ads, SEO, content SEO, GEO/AIO, copywriting, brand, storytelling, social media, data, AI/ML, UX, finance, legal, customer success, PR, and more.

See the full roster (34 agents) →

Note: Deadpool is the only agent that is permanently active in all workflows. All other agents (including Doom) are summoned based on the task. This is by design — the contrarian function must be structural, not optional, to effectively counter LLM sycophancy bias.

Supported Platforms (21)

IDE Platforms (16)

CLI Platforms (5)

For platform-specific setup guides and file structure details, see Platform Support →

Configuration

After installation, a .assemble.yaml file is created at the root of your project:

# Assemble — Project configuration
version: "1.1.2-beta.4"
profile: "custom"                 # startup | enterprise | agency | custom
langue_equipe: "english"          # Language for agent-to-agent communication
langue_output: "english"          # Language for produced deliverables
output_dir: "./assemble-output"   # Output directory for deliverables
platforms: [claude-code, cursor]  # Target platforms
agents: all                       # Activated agents (all or list)
workflows: all                    # Activated workflows (all or list)
governance: "none"                # none | standard | strict
yolo: false                       # Non-interactive chaining (no validation gates)
mcp: false                        # Local MCP server generation only
search: false                     # Web search protocol (agents verify with current data)
memory: false                     # Cross-session _memory.md
metrics: false                    # Workflow _metrics.md
installed_at: "2026-03-19"

Team Profiles

Profiles provide sensible defaults that can be overridden by explicit config:

Extensibility

Custom agents: Drop AGENT-*.md files in .assemble/agents/ — they're auto-discovered and merged during generation. Same slug overrides built-in.

Custom skills: Use npx cohesiumai-assemble import <path> to copy skill files into .assemble/skills/. They're included in the next generation.

Custom JavaScript adapters: A project cannot enable these from .assemble.yaml. Load adapters from .assemble/adapters/ only for a trusted project and only for the current command: npx cohesiumai-assemble --update --allow-plugins.

Windsurf MCP registration: mcp: true generates project-local files only. Writing to the Windsurf user profile is a separate, explicit action: npx cohesiumai-assemble --update --register-windsurf-mcp.

For details on MCP server, web search, cross-session memory, metrics, YOLO escalation levels, and governance, see the full documentation →

Workflows (15)

32 skills (28 reusable + 4 system) are also available. See the full skills reference →

Architecture

assemble/
  src/
    agents/             # 34 agent definition files (AGENT-*.md)
    skills/
      shared/           # 15 shared skills (multi-agent, includes web-research)
      specific/         # 17 specific skills (13 agent-specific + 4 system:
        # board-execution, doctor, doom-verdict, party-mode)
    workflows/          # 15 workflow definitions (YAML)
    orchestrator/       # ORCHESTRATOR.md (Jarvis)
    config/
      defaults.yaml     # Default configuration (profiles, MCP, memory, metrics)
      teams.yaml        # Team definitions (9 teams)
    commands/
      commands.yaml     # Registry of 11 primary commands + hidden shortcuts + internal skills
  generator/
    generate.js         # Main generator (profiles, custom agents/skills, MCP, memory, metrics)
    lib/
      profiles.js       # Team profiles (startup, enterprise, agency)
      mcp-generator.js  # MCP server + config generator
      agents-md-generator.js  # Universal AGENTS.md generator
      template-engine.js      # Template rendering (memory, metrics, search, governance strict)
    adapters/           # 21 platform adapters (16 IDE + 5 CLI)
  bin/
    cli.js              # Interactive installer (13-step wizard)
    doctor.js           # Health check (npx cohesiumai-assemble doctor)
    diff.js             # Dry run diff (npx cohesiumai-assemble diff)
    ls.js               # List active config (npx cohesiumai-assemble ls)
    import.js           # Import skills (npx cohesiumai-assemble import)
  tests/
    unit.test.js        # Unit tests for core functions
    snapshot.test.js    # Snapshot + qualitative tests
    integration-full.js # Full 21-platform integration tests
  .assemble/            # User extensibility (auto-detected)
    agents/             # Custom agents (AGENT-*.md)
    skills/             # Imported skills

Execution Flow

You type /go <request>
      |
      v
  Your LLM reads the generated Jarvis instructions
      |
      +-- Assesses complexity (TRIVIAL / MODERATE / COMPLEX)
      +-- Selects agents from generated configs
      |
      +── TRIVIAL → routes to single agent definition
      +── MODERATE → chains 2-3 agent definitions sequentially
      +── COMPLEX → follows Spec-Driven Methodology:
      |     1. SPECIFY (@professor-x) → spec.md
      |     2. PLAN (@tony-stark) → plan.md
      |     3. TASKS (@captain-america) → tasks.md
      |     4. IMPLEMENT (Board Execution for COMPLEX workflows) → _board.yaml + parallel ticket pipeline
      |     5. CLOSE (Jarvis) → _quality.md
      |
      v
  LLM executes using generated agent personas
      |
      +-- Reads agent definition → produces deliverables
      +-- Reads next agent definition → continues
      |
      v
  Consolidation → _summary.md + _quality.md

Note: Assemble generates the configuration. Your IDE/CLI and its LLM handle the runtime execution. Assemble has no daemon, no server, no process running.

Documentation

Contributing

See CONTRIBUTING.md for local setup, test requirements, and pull request guidance. Security reports must follow the private process in SECURITY.md.

License

MIT — An open-source project by Cohesium AI