OpenCode · Multi-Agent Orchestration

SENATE Speak the Order. Watch It Unfold.

✦

Nineteen specialized agents. Thirty-nine workflow skills.
One declaration: Don't learn orchestration. Just use Senate.

Begin Installation View on GitHub

19 Agents

39 Skills

5 Exec Modes

∞ Possibilities

What is Senate

The Assembly of Intelligence

Nineteen specialized agents, unified under a single orchestration layer — native to OpenCode.

Built for OpenCode

Senate is a complete multi-agent orchestration layer built natively for OpenCode. Every agent, skill, and workflow is designed for the OpenCode runtime — no wrappers, no compromises.

Configure once. Direct your agents. Watch the assembly work.

Zero Learning Curve

Senate is activated through natural language. Speak to it as you would a trusted colleague — the system routes your intent to the right specialist automatically.

Intelligent model routing ensures each task is handled by the right tier: Haiku for quick lookups, Sonnet for standard work, Opus for architecture.

"The senate does not merely deliberate — it executes. Where a single mind might hesitate, the assembly acts with coordinated purpose." — Senate Design Philosophy

Execution Modes

Six Pillars of Execution

Each mode is a distinct strategy — choose based on the nature of your task.

I · Persistent

Ralph

Relentless execution until the task is verified complete. Ralph never stops until the work is done and confirmed.

/ralph fix all TypeScript errors

II · Autonomous

Autopilot

Full autonomous execution from idea to working code. Ideal for end-to-end feature development with minimal guidance.

/autopilot build a REST API

III · Parallel

Ultrawork

Maximum parallel agent execution. Deploy burst parallelism for large refactors, fixes across multiple files, or time-critical work.

/ultrawork implement auth

IV · Coordinated

Team

N coordinated agents sharing a task list. Complex multi-step workflows benefit from a structured division of labour.

/team 3:executor "add feature X"

V · Verification

Ultra QA

QA cycling until the goal is met. Test, verify, fix, repeat — the system iterates until your quality bar is cleared.

/ultraqa verify all endpoints

VI · Clarity

Deep Interview

Socratic requirements gathering before execution. Exposes assumptions, scores ambiguity, and refuses to build until the spec is crystal clear.

/deep-interview "vague idea"

The Assembly

Nineteen Specialized Agents

Each agent masters a single domain. Together they govern the full spectrum of software creation.

Executor

Code implementation and refactoring

Architect

System design and architecture

Planner

Task sequencing and planning

Debugger

Root-cause analysis

Code Reviewer

Comprehensive code review

Security Reviewer

Security audits and vulnerability analysis

Test Engineer

Test strategy and coverage

Designer

UI/UX work and interface design

Writer

Documentation and technical writing

Analyst

Requirements analysis

Explore

Fast codebase search and navigation

Verifier

Completion verification

Tracer

Agent flow tracking

Git Master

Git operations and history management

Critic

Plan and design challenge

QA Tester

Interactive validation

Scientist

Research tasks

Code Simplifier

Code cleanup and clarity

Document Specialist

SDK and API documentation

Activation

Magic Keywords

Senate listens for intent. Speak naturally and the assembly activates the appropriate mode — no commands to memorize.

State Management

Senate persists state across sessions in .senate/ — keeping mode state, session notes, project memory, and planning documents available across every conversation.

"ralph", "don't stop" → Persistent execution mode

"autopilot", "build me" → Full autonomous mode

"ultrawork", "ulw" → Maximum parallelism

"deep interview" → Socratic clarification

"ralplan" → Consensus planning gate

"ultrathink" → Deep reasoning mode

"deslop", "anti-slop" → AI slop cleaner

"cancel", "stop" → Cancel active modes

Installation

Summon the Assembly

Two paths lead to Senate. Choose the one that suits your project.

# Clone Senate into your project
git clone https://github.com/yadav-prakhar/opencode-senate.git .opencode-senate

# Link to your project's .opencode directory
ln -s .opencode-senate/.opencode .opencode

Senate will be available in this project only. The .opencode/ symlink integrates seamlessly with OpenCode's plugin discovery.

# Install globally
npm install -g opencode-senate

# Or install as a project dependency
npm install opencode-senate

Global installation makes Senate available across all OpenCode projects on your machine.

// opencode.jsonc
{
  "plugin": ["opencode-senate"],
  "instructions": ["AGENTS.md"],
  "skills": {
    "paths": ["./.opencode/skills"]
  }
}

Add this to your project's opencode.jsonc to activate Senate. The plugin, instructions, and skill paths are loaded automatically.

Directory Structure

The Architecture of the Assembly

.opencode/
├── opencode.jsonc       # Main configuration
├── AGENTS.md            # Orchestration instructions
├── agent/               # 19 agent definitions
│   ├── executor.md
│   ├── architect.md
│   └── ...
├── skills/              # 39 workflow skills
│   ├── ralph/SKILL.md
│   ├── autopilot/SKILL.md
│   └── ...
├── command/             # Custom commands
├── tool/                # Custom tools
└── plugins/
    └── senate-plugin.ts  # Hook system plugin

.senate/                # Runtime state (auto-created)
├── state/               # Mode state files (JSON)
├── notepad.md           # Session notes
├── project-memory.json  # Cross-session knowledge
└── plans/               # Planning documents

Quick Start

Your First Session

Open an OpenCode session and address the assembly.

Execution Modes

/ralph fix all TypeScript errors
/autopilot build a REST API for tasks
/ultrawork implement auth in parallel
/team 3:executor "add feature X"
/ultraqa verify all endpoints

Planning Workflows

/plan refactor the auth module
/ralplan redesign the API layer
/deep-interview clarify requirements
/trace why is the build failing
/verify all acceptance criteria

Agent Commands

/ask architect "design a queue system"
/ask security-reviewer "audit auth"
/ask test-engineer "improve coverage"
/ask git-master "clean up history"
/ask critic "challenge this design"

Natural Language

# No slash command needed
"don't stop until the tests pass"
"ultrawork these 5 refactors"
"deep interview my requirements"
"ultrathink this architecture"
"cancel"  — stops active mode