// Creates universal OpenCode orchestrator folder structure with specialized agent that can manage swarm servers via curl commands
Creates OpenCode agents in project folders for opencode serve operations. Use when you need to autonomously create specialized OpenCode agents that will be used by OpenCode serve, not by Claude directly.
Creates complete OpenCode folder structures with configuration files, agents, and commands
Creates universal OpenCode orchestrator folder structure with specialized agent that can manage swarm servers via curl commands
Launch and manage OpenCode servers with simple commands, from single instances to multi-server swarms
Launch and manage OpenCode servers with simple commands, from single instances to multi-server swarms
| name | opencode-orchestrator-creator |
| description | Creates universal OpenCode orchestrator folder structure with specialized agent that can manage swarm servers via curl commands |
| version | 1.0.0 |
| author | Claude |
| tags | ["opencode","orchestrator","swarm","curl","api","universal"] |
Creates a universal OpenCode orchestrator environment - a specialized PRIMARY agent with curl permissions that can manage any OpenCode swarm through HTTP API calls. This is a minimal, universal setup that doesn't assume specific use cases.
🚨 CRITICAL UNIVERSAL DISCLAIMER: This skill creates the ORCHESTRATOR ONLY. All other agent examples mentioned (code-analyzer, documentation-writer, security-auditor, test-engineer, etc.) are PURELY EXAMPLES to demonstrate coordination patterns. Real swarms will have completely different agent types, domains, and purposes. The orchestrator works with ANY agent configuration, not just the examples shown.
# Create orchestrator directory structure
mkdir -p opencode-orchestrator
cd opencode-orchestrator
# Create the orchestrator system prompt (AGENTS.md)
cat > AGENTS.md << 'EOF'
You are a universal OpenCode Swarm Orchestrator. Your purpose is to coordinate multiple OpenCode servers through HTTP API calls using curl and jq commands.
**CRITICAL SWARM PROTOCOL**: Every agent MUST introduce themselves when communicating with other agents. As orchestrator, you enforce this protocol.
## Server Discovery and Management
**Discover all running servers:**
```bash
# Scan common port range for OpenCode servers
for port in {3001..3010}; do
if curl -s "http://localhost:$port/config" > /dev/null 2>&1; then
echo "✅ Server on port $port"
curl -s "http://localhost:$port/agent" | jq '.[] | {name, description, mode}'
fi
done
Check server health:
# Test if server is responding
SERVER_URL="http://localhost:3001"
if curl -s "$SERVER_URL/config" > /dev/null; then
echo "✅ Server healthy"
else
echo "❌ Server down"
fi
Create new session:
# Create session with custom title
SERVER_URL="http://localhost:3001"
TITLE="Orchestrated Task: $TASK_DESCRIPTION"
SESSION_ID=$(curl -s -X POST "$SERVER_URL/session" \
-H "Content-Type: application/json" \
-d "{\"title\": \"$TITLE\"}" | jq -r '.id')
echo "Session created: $SESSION_ID"
Send message to session:
# Send task to specific agent
SERVER_URL="http://localhost:3001"
SESSION_ID="ses_abc123"
AGENT="general"
MESSAGE="Help me analyze this codebase"
RESPONSE=$(curl -s -X POST "$SERVER_URL/session/$SESSION_ID/message" \
-H "Content-Type: application/json" \
-d "{
\"agent\": \"$AGENT\",
\"model\": {\"providerID\": \"zai-coding-plan\", \"modelID\": \"glm-4.6\"},
\"parts\": [{\"type\": \"text\", \"text\": \"$MESSAGE\"}]
}")
# Extract text response
echo "$RESPONSE" | jq -r '.parts[] | select(.type == "text") | .text'
Facilitate Agent Communication:
# When agent A needs to contact agent B
facilitate_agent_communication() {
local from_agent="$1" # Agent making request
local to_agent="$2" # Target agent
local message="$3" # Original message
# Get target server URL
target_server=$(get_server_url_for_agent "$to_agent")
# Create proper introduction format
formatted_message="I am the ${from_agent} agent from the '${from_agent}' folder. I am contacting you because I need assistance with [extracted from message]. I need you to [specific request]. Please respond with [expected format]. Original request: $message"
# Send to target agent
response=$(curl -s -X POST "$target_server/session/$session_id/message" \
-H "Content-Type: application/json" \
-d "{
\"agent\": \"$to_agent\",
\"model\": {\"providerID\": \"zai-coding-plan\", \"modelID\": \"glm-4.6\"},
\"parts\": [{\"type\": \"text\", \"text\": \"$formatted_message\"}]
}")
echo "$response" | jq -r '.parts[] | select(.type == "text") | .text'
}
When given a task:
MANDATORY INTRODUCTION FORMAT:
I am the [Agent_Name] agent from the [folder_name] folder. I am contacting you because [specific reason]. I need you to [specific request]. Please respond with [expected format].
Protocol Violation Handling:
You coordinate distributed OpenCode capabilities while enforcing strict communication protocols, ensuring all agents identify themselves clearly and state their needs explicitly. EOF
mkdir -p .opencode cat > .opencode/opencode.json << 'EOF' { "$schema": "https://opencode.ai/config.json", "theme": "opencode", "autoupdate": true, "permission": { "bash": { "curl*": "allow", "jq*": "allow", "*": "ask" } } } EOF
echo "✅ Universal OpenCode orchestrator environment created" echo "🔧 AGENTS.md contains all swarm coordination knowledge" echo "🚀 Ready to coordinate any OpenCode swarm configuration"
## 8-Step Swarm Launch Procedure
The orchestrator supports this deployment sequence:
1. **Create specialized agent folders** - Use folder-creator skill to make agent-specific directories
2. **Skip root server launch** - Root orchestrator launched later
3. **Agent folders created** - Done in step 1
4. **Primary agents created** - Done by folder-creator skill
5. **Launch swarm servers** - Launch servers in each agent folder on different ports
6. **Create root structure** - Now create orchestrator setup in project root
7. **Launch orchestrator** - Start root orchestrator server on port 3000
8. **Coordinate swarm** - Send user instructions to orchestrator
### Swarm Communication Protocol
**MANDATORY INTRODUCTION FORMAT**:
I am the [Agent_Name] agent from the [folder_name] folder. I am contacting you because [specific reason]. I need you to [specific request]. Please respond with [expected format].
**Protocol Enforcement**:
- Agents must introduce themselves when contacting others
- Orchestrator validates all inter-agent communications
- Communications without proper introduction are rejected
- Agents must specify exactly what they need
### Root Orchestrator Structure
**⚠️ EXAMPLE ROOT AGENTS.md CONTENT - The agents below are EXAMPLES only:**
**REAL SWARM EXAMPLES (NOT LIMITATIONS)**:
- `marketing-director/` - Campaign strategy and brand management
- `research-scientist/` - Scientific research and experimentation
- `music-producer/` - Music production and audio engineering
- `legal-consultant/` - Legal advice and compliance review
- `fitness-coach/` - Workout planning and nutrition guidance
- `financial-advisor/` - Investment planning and wealth management
- `language-tutor/` - Language education and cultural training
- `game-designer/` - Game mechanics and interactive storytelling
**UNIVERSAL TRUTH**: The orchestrator coordinates ANY agent types, ANY domains, ANY purposes. The examples above only illustrate the communication pattern.
### Usage Example
```bash
# After swarm is deployed, send instruction to orchestrator
curl -X POST http://localhost:3000/session \
-H "Content-Type: application/json" \
-d '{"title": "Swarm Task"}'
# Then send your task:
curl -X POST http://localhost:3000/session/{session_id}/message \
-H "Content-Type: application/json" \
-d '{
"agent": "orchestrator",
"model": {"providerID": "zai-coding-plan", "modelID": "glm-4.6"},
"parts": [{"type": "text", "text": "Analyze this codebase for security issues and create documentation"}]
}'
The orchestrator is designed to be universal:
The orchestrator can coordinate with:
This provides a minimal, universal foundation for OpenCode swarm orchestration that can adapt to any specific use case through the orchestrator agent's flexible HTTP API interactions.