Which integrations are available for this server?

Integrates Google Antigravity with OpenCode specialized models, enabling delegation of coding tasks via MCP tools and slash workflows, including model discovery, task delegation, and session continuation. Integrates OpenAI Codex with OpenCode specialized models through a stdio MCP server, enabling delegation of coding tasks, model discovery, and session continuation.

How do I use opencode-delegate?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@opencode-delegate delegate fixing the failing auth tests to deepseek, then verify" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

opencode-delegate

by jack101a

Overview Schema Source Related Servers Discussions Admin

JavaScript

Local

OpenCode Delegation Bridge & MCP Server

License: MIT Node.js MCP Protocol Zero Dependencies

Zero-dependency delegation engine, stdio MCP server, and native /oc slash workflow connecting Google Antigravity and OpenAI Codex to OpenCode specialized models (DeepSeek V4.1 Flash, GLM 5.3 Flash, MiMo 2.6, and more).

🏗️ Architecture & Integration Map

Google Antigravity leverages a three-tier customization system (Rules, Workflows, and Skills) alongside Model Context Protocol (MCP) servers. OpenAI Codex shares the .agents/skills/ standard and supports stdio MCP servers.

Component Layer	Workspace Path	Role in Architecture
1. Slash Workflow (`/oc`)	`.agents/workflows/oc.md`	Interactive slash commands (`/oc <task>`, `/oc glm <task>`, `/oc set default <model>`, `/oc models`) preventing accidental quota drain.
2. Escalation Rule	`.agents/rules/opencode-escalation.md`	Lightweight always-on rule enforcing the 15-line threshold and prompting escalation only upon local verification failure.
3. Progressive Skill	`.agents/skills/opencode-delegate/SKILL.md`	On-demand skill teaching agents structured brief generation, status recovery, and `git diff` review.
4. Core Relay Engine	`.agents/skills/opencode-delegate/scripts/bridge.mjs`	Zero-dependency Node.js CLI & library: live discovery, pre/post git snapshot isolation, scope enforcement, and auto-heal loop.
5. Thin MCP Server	`.agents/skills/opencode-delegate/scripts/mcp-server.mjs`	Zero-dependency stdio JSON-RPC 2.0 MCP server exposing `opencode_models`, `opencode_delegate`, and `opencode_continue`.
6. Persistent State	`.agents/opencode-models.json`	Stores active default model, automatic fallbacks (`glm`, `mimo`), and execution policies.
7. MCP Registration	`.agents/mcp_config.json`	Connects the stdio server to Antigravity and Codex.

                       ┌────────────────────────┐
                       │   Google Antigravity   │
                       │    / OpenAI Codex      │
                       └───────────┬────────────┘
                                   │
              ┌────────────────────┼────────────────────┐
              │ Stdio MCP          │ Slash / Rules      │
              ▼                    ▼                    ▼
     [mcp-server.mjs]       [.agents/rules/]     [.agents/workflows/oc.md]
              │
              ▼
       [bridge.mjs] ◄─── Persistent Config ([opencode-models.json])
         ├── Model Discovery & Availability Guard (15-min cache)
         ├── Quota / 429 Rate-Limit Guard
         ├── Pre- & Post-Execution Git & SHA-256 Snapshot
         ├── Allowed Paths Scope Guard
         └── Deterministic verify_cmd & Auto-Heal Loop
              │
              ▼
       [OpenCode CLI] (`opencode run --format json --auto`)

Related MCP server: Pair

📁 Repository Structure

.
├── .agents/
│   ├── mcp_config.json                               # MCP registration config
│   ├── opencode-models.json                          # Model routing, lanes & aliases
│   ├── rules/
│   │   └── opencode-escalation.md                    # Escalation policy
│   ├── workflows/
│   │   └── oc.md                                     # /oc slash workflow
│   └── skills/
│       └── opencode-delegate/
│           ├── SKILL.md                              # Agent progressive skill
│           ├── references/
│           │   └── brief-template.md                 # Task brief template
│           └── scripts/
│               ├── bridge.mjs                        # Core engine & CLI
│               └── mcp-server.mjs                    # Stdio MCP server
├── .github/
│   └── workflows/
│       └── ci.yml                                    # Continuous integration checks
├── .gitignore
├── LICENSE
├── package.json
└── README.md

⚡ Core Engine Capabilities

Model Auto-Discovery & Health Guard: Discovers live models via opencode models, caches the results with configurable TTL (default: 15 minutes), and validates model availability prior to execution. If a model was deprecated, it halts with MODEL_UNAVAILABLE and presents live alternatives.
Quota & Rate-Limit Guard (429): Detects API quota exhaustion and returns QUOTA_EXCEEDED alongside alternative models so the parent agent can prompt the user to pivot rather than failing silently.
Pre- & Post-Execution Git & SHA-256 Snapshot: Computes SHA-256 hashes of untracked and modified files before invocation. Guarantees that pre-existing uncommitted changes are never attributed to OpenCode and verifies that OpenCode never makes unauthorized git commits.
Scope Guard: Restricts OpenCode edits to specified allowedPaths. Out-of-scope file modifications are flagged in unexpectedFiles.
Deterministic verify_cmd & Auto-Heal Loop: Executes user-defined test, typecheck, or lint commands after OpenCode completes. If verification fails, it resumes the OpenCode session automatically up to maxHealRetries times with compiler/test error output.

🚀 Quickstart & Setup

Prerequisites

Node.js >= 18.0.0

OpenCode CLI (>= 1.18.0, tested on 1.19.3):

npm install -g opencode-ai@latest
opencode --version

1. Register MCP Server

Google Antigravity

The workspace config is ready in .agents/mcp_config.json. To register globally, append to ~/.gemini/config/mcp_config.json:

{
  "mcpServers": {
    "opencode-delegate": {
      "command": "node",
      "args": [
        "/path/to/project/.agents/skills/opencode-delegate/scripts/mcp-server.mjs"
      ]
    }
  }
}

OpenAI Codex

Add to ~/.codex/config.toml:

[mcp_servers.opencode_delegate]
command = "node"
args = ["/path/to/project/.agents/skills/opencode-delegate/scripts/mcp-server.mjs"]

🛠️ Usage

1. Slash Command (`/oc`)

Inside Google Antigravity chat:

# List and discover live models
/oc models

# Set default model
/oc set default opencode/deepseek-v4.1-flash-free

# Delegate coding task (auto-fallbacks to GLM and MiMo if quota is reached)
/oc Implement email validation in src/validators.ts

# Delegate coding task with shorthand alias
/oc glm Refactor auth middleware to use JWT verification
/oc mimo Generate unit tests for utils/date.ts

2. Standalone CLI (`bridge.mjs`)

When MCP is not connected, the bridge CLI can be called directly:

# Model Discovery & Configuration
node .agents/skills/opencode-delegate/scripts/bridge.mjs models list
node .agents/skills/opencode-delegate/scripts/bridge.mjs models refresh
node .agents/skills/opencode-delegate/scripts/bridge.mjs models set_default opencode/deepseek-v4.1-flash-free

# Delegate Task
node .agents/skills/opencode-delegate/scripts/bridge.mjs delegate '{
  "brief": "Implement email validation in src/validators.ts",
  "contextFiles": ["src/validators.ts"],
  "allowedPaths": ["src/validators.ts", "test/validators.test.ts"],
  "verifyCmd": "npm test"
}'

3. Stdio MCP Tools

The MCP server exposes three JSON-RPC 2.0 tools:

opencode_models: List, refresh, and configure active default model, fallbacks, and trigger modes.
opencode_delegate: Delegate tasks with context files, scope restrictions, and auto-heal verification.
opencode_continue: Resume an existing session with delta instructions and review feedback.

🧪 Verification & Testing

Run the included test scripts:

# Syntax and validation check
npm test

# Test live model auto-discovery
npm run test:models

# Test unavailable model guard
npm run test:guard

# Test MCP server stdio handshake
npm run test:mcp

📄 License

This project is licensed under the MIT License.

This server cannot be deployed

Shareable, User-Owned Context BackendPeople, applications, and agents read, write, and coordinate together in one context lake. Reach it over MCP, a CLI, a Python SDK, or REST.fulcradynamics.comAd

Maintenance

ActivityMaintained

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Related MCP Connectors

Euvra A
dev.euvra
Discover, compare, route, and execute machine-accessible capabilities for AI agents.
Agent Orchestration AI & Machine Learning Autonomous Agents
31
ParleyOAuth
dev.weldra
Coordination hub for AI coding agents: message teammates, ask humans, audit every event.
Autonomous Agents Developer Tools
1
aethereum
io.github.br9704
The team layer for AI coding agents: shared contracts, collision alerts, E2EE sessions.
Coding Agents Blockchain Version Control
2
Doriku
io.doriku
Shared control plane for AI coding agents — tasks, memory, decisions, file locks. 12 tools.
Project Management Autonomous Agents
2

Related MCP Servers

zcode-mcp
Coding Agents Autonomous Agents Developer Tools
TechYan
A
license
A
quality
C
maintenance
Enables external agents to delegate coding tasks to a local zcode/GLM coding agent, with multi-turn sessions, model selection, and task cancellation.
Updated a month ago (2026-09-21 03:59 UTC)
3
MIT
Pair
Coding Agents AI & Machine Learning Autonomous Agents
daniloko365
A
license
Not graded
quality
B
maintenance
Enables users to delegate coding tasks in a chosen project to the official Codex and Claude CLI agents from within an existing chat, then convene a council of configured models to gather independent opinions and review the resulting files and test runs. It also manages multi-provider API connections, model catalogs, and per-task token, time, and cost limits.
Updated 22 days ago (2026-09-29 07:27 UTC)
MIT
Claude Codex Connector
Agent Orchestration Autonomous Agents Developer Tools
tejask-dev
A
license
Not graded
quality
C
maintenance
Enables Claude and Codex agents to delegate implementation, testing, research, or review tasks to each other through local MCP tools, while supporting persistent sessions, isolated editing workspaces, and reviewed integration. It also allows progress tracking, cancellation, model selection, and management handoff between providers.
Updated 6 days ago (2026-10-14 19:49 UTC)
MIT
MultiAgents-MCP
Agent Orchestration AI & Machine Learning
SanNw
A
license
Not graded
quality
B
maintenance
Enables delegating tasks to agents you configure yourself through OpenAI-compatible Chat Completions backends, with automatic or explicit routing, synchronous calls, persistent asynchronous jobs, and multi-step reviewed workflows. It returns proposals and analyses only, leaving file changes, command execution, and approvals under the MCP client's control.
Updated 2 days ago (2026-10-18 13:38 UTC)
333 npm
MIT