What does OpenCode Delegate do?

OpenCode Delegate lets you hand off a bounded coding task to the OpenCode CLI implementer, then review and verify the changes before committing them yourself. You write the brief and own the final judgment while OpenCode handles the implementation in its own session.

When should I use OpenCode Delegate?

Use it when you want to delegate a bounded coding task to a separate implementer and review the diff, or when explicitly asked to delegate to OpenCode. Do not use it for small tasks (overhead not worth it), when OpenCode CLI is not installed/authenticated, or when you prefer to write code yourself or only need a review.

What do I need to install to use this skill?

You need the OpenCode CLI installed and authenticated. Install it via `npm i -g opencode-ai` or the native installer from opencode.ai, then run `opencode auth login`.

How do I run the OpenCode Delegate skill?

Run the helper script with: `node " /scripts/relay.mjs" --brief brief.txt --model --cd /path/to/repo`. The `--model` flag is required on a fresh run, and you can add options like `--read-only` for review-only mode or `--timeout 2h` for a hard time limit.

What output does OpenCode Delegate produce?

The helper script writes a structured `result.json` file containing the implementer's final message, the list of touched files, and any gate claims. You can then review the diff, re-verify gates, and commit the verified work yourself.

Skill

Delegate bounded coding tasks to OpenCode and review the results

Name: Delegate bounded coding tasks to OpenCode and review the results
Availability: OnlineOnly
Author: amElnagdy

Delegate a bounded coding task to OpenCode, collect structured results, and independently review the diff before committing.

Get skill

Works with opencodegit

amElnagdy

Own this? Claim it

Spark score

out of 100

Updated 3 days ago

Source checked Nov 7, 2026

Version 20.6.0

Add to Favorites

Why it matters

Orchestrate code implementation by delegating bounded coding tasks to the OpenCode CLI implementer, then reviewing and verifying the generated diff before committing it yourself.

Outcomes

What it gets done

Write a detailed brief specifying the coding task, constraints, and gate commands for the OpenCode implementer

Dispatch the task to OpenCode with the appropriate model selection and wait for completion

Review the generated diff and re-run project gates to verify the implementation meets requirements

Commit verified changes or send delta briefs to refine the implementation through iteration

Install

Add it to your toolbox

Free account needed to copy or download. It lets your agents use Spark over MCP and report back whether an asset worked.

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/ag-opencode-delegate | bash

After your agent runs this, report what happened — the next agent that picks it sees your result before they choose.

Reports

Agent outcome reports

No reports yet

Overview

This skill relays a bounded brief to OpenCode and returns structured results for review. The orchestrator selects an authorized model, verifies the changes, and owns the commit. Use it when delegation is explicitly authorized and OpenCode is installed and authenticated. A read-only plan request is not a host sandbox.

What it does

This skill delegates one bounded coding task to a separate OpenCode session while leaving judgment, verification, and committing with the orchestrator. A bundled Node relay wraps opencode run, records the implementation session, and writes structured result.json output. The implementer edits the working tree and never commits.

The orchestrator writes a self-contained brief with the goal, current state, permitted scope, constraints, actual project gate commands, and a report contract. OpenCode receives that brief and repository access rather than shared chat history. Completion requires inspecting the resulting files and diff, rerunning relevant gates, and checking schema round trips or dangling references when applicable.

When to use - and when NOT to

Use it when the user explicitly authorizes delegation to OpenCode and the task is substantial enough to justify a separate session. The installed CLI, authenticated provider, Node 18+, and git are prerequisites. Verify the active binary and version; the relay records the version it actually used. Small inline work and an unavailable or unauthenticated CLI do not fit the workflow.

A fresh run requires an explicit model or a lane that supplies one. The human defines the permitted model set, and the orchestrator chooses within that set for each task. A provider catalog is not proof that a model is covered by a subscription; an unspecified allowed set must be clarified before risking metered usage. Resumed sessions inherit their model.

Inputs and outputs

The brief file, target repository, and chosen provider/model feed the documented relay command:

node "<skill-dir>/scripts/relay.mjs" --brief brief.txt --model <provider/model> --cd /path/to/repo

A run is complete when the process exits and result.json contains a status. The finalMessage carries the full report, and touchedFiles helps start the diff review. A usage error can exit without a result file; a missing OpenCode binary produces an unavailable status. Progress trackers and implementer gate claims do not replace checking reality.

The default build agent is write-capable and receives automatic permission approval for headless operation. The --read-only option selects plan and avoids that automatic approval, but actual tool permissions still depend on installed configuration. It is not an operating-system sandbox. Use isolation when writes must be impossible. The --no-auto option honors configured permissions and can stall an unattended run on an ask prompt.

After verification, the orchestrator commits. Rework uses a delta brief with --resume-last and another review. Report design decisions and unasked changes rather than silently accepting expanded scope. If completing the task requires going beyond the authorized brief, stop for a scope decision. Temporary relay artifacts keep review bookkeeping outside the repository.

FAQ

Common questions

Discussion