# multi-platform-async

> Asynchronously delegate tasks across multiple AI platforms (Gemini, Claude, Codex, OpenCode, Augment) for parallel execution and cross-platform orchestration

- Author: Claude Assistant
- Repository: mfethe1/skills
- Version: 20260123221508
- Stars: 0
- Forks: 0
- Last Updated: 2026-02-06
- Source: https://github.com/mfethe1/skills
- Web: https://mule.run/skillshub/@@mfethe1/skills~multi-platform-async:20260123221508

---

---
name: multi-platform-async
description: Asynchronously delegate tasks across multiple AI platforms (Gemini, Claude, Codex, OpenCode, Augment) for parallel execution and cross-platform orchestration
triggers:
  - async
  - parallel
  - multi-agent
  - delegate-all
  - cross-platform
allowed-tools:
  - Read
  - Write
  - Edit
  - Bash
  - Grep
  - Glob
---

# Multi-Platform Async Orchestration

Use this skill to run tasks **asynchronously** across multiple AI platforms in parallel, collect results, and synthesize them.

## Available Platforms (with YOLO Mode)

| Platform | YOLO Command | Safe Command | Best For |
|----------|--------------|--------------|----------|
| **Claude** | `claude --dangerously-skip-permissions --print` | `claude --print` | Complex reasoning, code review |
| **Gemini** | `gemini --yolo` | `gemini` | Research, large context |
| **Codex** | `codex --yolo` | `codex --full-auto` | Code generation, refactoring |
| **OpenCode** | `opencode run` (config-based) | `opencode run` | Local execution, file ops |
| **Augment** | `auggie` | `auggie` | Codebase-aware tasks |

### YOLO Mode Flags Reference

```bash
# Show full YOLO configuration for all platforms:
python skills/multi-platform-async/scripts/async_dispatch.py yolo-info
```

## Quick Start

### 1. Fire-and-Forget Parallel Tasks
```bash
# Start multiple tasks in background
claude --print "Analyze architecture of src/" > /tmp/claude_task.txt 2>&1 &
gemini "Research best practices for X" > /tmp/gemini_task.txt 2>&1 &
codex --full-auto "Refactor function Y" > /tmp/codex_task.txt 2>&1 &

# Wait for all to complete
wait

# Collect results
cat /tmp/claude_task.txt /tmp/gemini_task.txt /tmp/codex_task.txt
```

### 2. Structured Async Dispatch
```bash
# Use the orchestrator dispatcher
python orchestrator/dispatcher.py dispatch \
  --agent claude \
  --message "Analyze the codebase structure" \
  --async
```

### 3. Cross-Platform Pipeline
```bash
# Step 1: Research with Gemini
gemini "Research: What are the best patterns for X?" > research.md

# Step 2: Generate code with Codex
codex --full-auto "Based on research.md, implement the solution" 

# Step 3: Review with Claude
claude --print "Review the implementation for security issues"
```

## Async Patterns

### Pattern A: Fan-Out/Fan-In
Dispatch same question to multiple models, synthesize best answer:

```bash
#!/bin/bash
QUERY="How should we implement feature X?"

# Fan out
claude --print "$QUERY" > /tmp/claude.txt &
gemini "$QUERY" > /tmp/gemini.txt &
codex --full-auto "$QUERY" > /tmp/codex.txt &
wait

# Fan in - synthesize
echo "=== Claude ===" && cat /tmp/claude.txt
echo "=== Gemini ===" && cat /tmp/gemini.txt  
echo "=== Codex ===" && cat /tmp/codex.txt
```

### Pattern B: Specialized Delegation
Route tasks to the best platform for each:

```bash
# Research → Gemini
gemini "Research: State of the art in X" > research.md &

# Code Analysis → Claude
claude --print "Analyze complexity of src/main.py" > analysis.md &

# Code Generation → Codex  
codex --full-auto "Generate tests for utils.py" &

wait
```

### Pattern C: RLM-Style Chunked Processing
For large contexts, use RLM pattern with async sub-calls:

```bash
# Initialize RLM REPL
python skills/rlm/scripts/rlm_repl.py init large_file.txt

# Create chunks
python skills/rlm/scripts/rlm_repl.py exec -c "paths = write_chunks('.rlm_chunks', size=100000)"

# Process chunks in parallel across platforms
for chunk in .rlm_chunks/*.txt; do
  claude --print "Analyze: $(cat $chunk)" > "${chunk}.analysis" &
done
wait

# Synthesize
cat .rlm_chunks/*.analysis | claude --print "Synthesize these findings"
```

## Platform-Specific YOLO Configuration

### Claude Code
```bash
# YOLO flag: --dangerously-skip-permissions
# One-time setup (run once, select 'yes' when prompted):
claude --dangerously-skip-permissions

# Then use for autonomous operation:
claude --dangerously-skip-permissions --print "your prompt"
```
- Best for: reasoning, code review, synthesis

### Gemini CLI
```bash
# YOLO flag: --yolo (or --approval-mode=yolo)
gemini --yolo "your prompt"

# Interactive toggle: Ctrl+Y

# Or configure in ~/.gemini/settings.json:
# { "tools": { "allowed": ["*"] } }
```
- Large context window (1M+ tokens)
- Best for: research, document analysis

### OpenAI Codex
```bash
# YOLO flag: --dangerously-bypass-approvals-and-sandbox (alias: --yolo)
codex --yolo "your prompt"

# Safer auto mode (still prompts for network/external):
codex --full-auto "your prompt"

# Or configure in ~/.codex/config.toml:
# approval_policy = "never"
# sandbox_mode = "danger-full-access"
```
- Best for: code generation, refactoring

### OpenCode
```json
// Configure in opencode.json (no CLI flag):
{
  "permission": {
    "write": "allow",
    "edit": "allow",
    "bash": "allow"
  }
}
```
```bash
# Then run:
opencode run "your prompt"
```
- Best for: file operations, local commands

### Augment (auggie)
```bash
# Check for available flags:
auggie --help
```
- Codebase-aware retrieval
- Best for: codebase Q&A, symbol lookup

## Error Handling

Always capture stderr and check exit codes:
```bash
if claude --print "task" > result.txt 2>&1; then
  echo "Success: $(cat result.txt)"
else
  echo "Failed: $(cat result.txt)"
fi
```

## Verification

### Script Validation
Verify scripts work correctly before using:

1. **Syntax Check**
   ```bash
   python -m py_compile scripts/<script_name>.py
   ```

2. **Help Test**
   ```bash
   python scripts/<script_name>.py --help
   ```

3. **Dry Run** (if supported)
   ```bash
   python scripts/<script_name>.py --dry-run <test_args>
   ```

### Execution Verification
After running scripts:
- Check exit code (0 = success)
- Review stdout/stderr for errors
- Verify expected output files exist

### Failure Handling
If script execution fails:
1. Check error message for root cause
2. Verify input parameters are correct
3. Check dependencies are installed
4. Retry with verbose flag if available



## References
- [RLM Paper](https://arxiv.org/abs/2512.24601)
- [rand/rlm-claude-code](https://github.com/rand/rlm-claude-code)
- [brainqub3/claude_code_RLM](https://github.com/brainqub3/claude_code_RLM)