remote-code-agents

name	remote-code-agents
description	Delegate tasks to remote Claude Code agent containers for parallel execution, long-running analysis, or resource-intensive operations.

Remote Code Agents

Core Principle

When facing long-running tasks, complex analysis, or workloads better suited for dedicated compute resources, delegate them to remote Claude Code agent containers rather than executing locally.

Note: This skill supports both Claude Code agents (production-ready) and OpenRouter agents (⚠️ experimental, multi-model support).

When to Use This Skill

Always Use When:

• Long-running analysis that would block current workflow (> 5 minutes)
• Resource-intensive tasks like full codebase analysis or performance profiling
• Parallel workload distribution across multiple specialized agents
• Background research that doesn't block current development

Example Scenarios:

• Code review of large pull requests
• Security audit of entire codebase
• Performance optimization analysis
• Documentation generation for multiple modules
• Test generation for legacy code
• Dependency update research

Environment Configuration

Remote code agents require the following environment variables:

# Required: API endpoint for your remote agents
export REMOTE_AGENT_API_URL="http://your-agent-host:8080"

# Required: API key for authentication
export REMOTE_AGENT_API_KEY="your-secure-api-key"

# Optional: Default agent type
export REMOTE_AGENT_DEFAULT_TYPE="general"

Note: Never commit API keys or internal endpoints to version control. Use:

• .env files (gitignored)
• Secret management systems (Vault, AWS Secrets Manager)
• CI/CD secret variables

Agent Types

General Agent

Use for: Coding, debugging, refactoring, feature implementation

AGENT_TYPE=general

Research Agent

Use for: Analysis, documentation, architecture review, research

AGENT_TYPE=research

Testing Agent

Use for: Code review, test generation, QA analysis

AGENT_TYPE=testing

Integration Patterns

1. Command-Line Delegation

If you have the claude-task CLI installed:

# Submit a task
TASK_ID=$(claude-task submit \
  "Analyze this codebase for performance bottlenecks in API endpoints" \
  --repo https://github.com/org/repo \
  --type research)

# Check status later
claude-task status $TASK_ID

# Wait for completion
claude-task wait $TASK_ID

2. API-Based Delegation

Using curl or HTTP clients:

# Submit task
curl -X POST "${REMOTE_AGENT_API_URL}/tasks" \
  -H "X-API-Key: ${REMOTE_AGENT_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Review this code for security vulnerabilities",
    "repo_url": "https://github.com/org/repo",
    "branch": "main",
    "agent_type": "testing"
  }'

# Response: {"task_id": "uuid", "status": "submitted"}

# Check status
curl -H "X-API-Key: ${REMOTE_AGENT_API_KEY}" \
  "${REMOTE_AGENT_API_URL}/tasks/${TASK_ID}"

# Get results
curl -H "X-API-Key: ${REMOTE_AGENT_API_KEY}" \
  "${REMOTE_AGENT_API_URL}/tasks/${TASK_ID}/output"

3. CI/CD Integration

GitLab CI Example

code-review:
  stage: review
  script:
    - |
      TASK_ID=$(curl -X POST "${REMOTE_AGENT_API_URL}/tasks" \
        -H "X-API-Key: ${REMOTE_AGENT_API_KEY}" \
        -H "Content-Type: application/json" \
        -d "{
          \"prompt\": \"Review this merge request for bugs and security issues\",
          \"repo_url\": \"${CI_REPOSITORY_URL}\",
          \"branch\": \"${CI_COMMIT_REF_NAME}\",
          \"agent_type\": \"testing\"
        }" | jq -r '.task_id')

      # Wait for completion (with timeout)
      for i in {1..60}; do
        STATUS=$(curl -s -H "X-API-Key: ${REMOTE_AGENT_API_KEY}" \
          "${REMOTE_AGENT_API_URL}/tasks/${TASK_ID}" | jq -r '.status')

        [ "$STATUS" = "completed" ] && break
        sleep 10
      done

      # Get and display results
      curl -s -H "X-API-Key: ${REMOTE_AGENT_API_KEY}" \
        "${REMOTE_AGENT_API_URL}/tasks/${TASK_ID}/output"
  only:
    - merge_requests

GitHub Actions Example

- name: Delegate to Remote Agent
  env:
    REMOTE_AGENT_API_URL: ${{ secrets.REMOTE_AGENT_API_URL }}
    REMOTE_AGENT_API_KEY: ${{ secrets.REMOTE_AGENT_API_KEY }}
  run: |
    TASK_ID=$(curl -X POST "${REMOTE_AGENT_API_URL}/tasks" \
      -H "X-API-Key: ${REMOTE_AGENT_API_KEY}" \
      -H "Content-Type: application/json" \
      -d '{
        "prompt": "Generate tests for new features",
        "repo_url": "${{ github.repository }}",
        "agent_type": "testing"
      }' | jq -r '.task_id')

    echo "Task submitted: ${TASK_ID}"

4. From Current Session

When working interactively and you need to delegate:

# Explain to user what you're doing
echo "This analysis will take ~15 minutes. Delegating to remote agent..."

# Submit task
TASK_ID=$(curl -X POST "${REMOTE_AGENT_API_URL}/tasks" \
  -H "X-API-Key: ${REMOTE_AGENT_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Perform comprehensive security audit of authentication system",
    "repo_url": "https://github.com/org/repo",
    "agent_type": "research"
  }' | jq -r '.task_id')

echo "Task ID: ${TASK_ID}"
echo "You can check status with: curl -H 'X-API-Key: ${REMOTE_AGENT_API_KEY}' ${REMOTE_AGENT_API_URL}/tasks/${TASK_ID}"

Task Lifecycle

States

• pending: Task queued, waiting for agent
• processing: Agent actively working on task
• completed: Task finished successfully
• failed: Task encountered errors

Monitoring

# List all tasks
curl -H "X-API-Key: ${REMOTE_AGENT_API_KEY}" \
  "${REMOTE_AGENT_API_URL}/tasks"

# Filter by status
curl -H "X-API-Key: ${REMOTE_AGENT_API_KEY}" \
  "${REMOTE_AGENT_API_URL}/tasks?status=completed"

# Get available agents
curl -H "X-API-Key: ${REMOTE_AGENT_API_KEY}" \
  "${REMOTE_AGENT_API_URL}/agents"

Best Practices

1. Clear Task Descriptions

Be specific in your prompts:

❌ Bad: "Fix bugs" ✅ Good: "Review the authentication module for security vulnerabilities, focusing on JWT validation and password hashing"

2. Choose Appropriate Agent Type

• General: Implementation, debugging, refactoring
• Research: Analysis, documentation, investigation
• Testing: Reviews, test generation, QA

3. Don't Wait for Long Tasks

For tasks > 5 minutes:

# Submit and continue working
TASK_ID=$(submit_task "Long analysis task")
echo "Check later: claude-task status ${TASK_ID}"

# Return to it later when needed

4. Security Considerations

• Never expose API keys in code
• Use environment variables or secret management
• Rotate API keys regularly
• Limit agent access to necessary repositories only

5. Repository Access

Ensure remote agents can access repositories:

• Use public repos, OR
• Configure SSH keys/tokens on agent host, OR
• Use repository mirrors accessible to agents

Setting Up Remote Agents

If you want to set up your own remote agent infrastructure:

Requirements

• Docker-capable server (Linux, macOS, Windows)
• Anthropic API key
• Network accessibility (VPN, Tailscale, or public IP)

Basic Setup

# Create agent directory
mkdir -p ~/claude-agents

# Configure environment
cat > ~/claude-agents/.env <<EOF
ANTHROPIC_API_KEY=sk-ant-api03-your-key-here
API_KEY=your-secure-random-api-key
EOF

# Deploy using Docker Compose
# (See repository examples for docker-compose.yml)

docker-compose up -d

Recommended: Use Private Network

• Tailscale, ZeroTier, or WireGuard VPN
• Avoid exposing to public internet
• Use mTLS if public exposure required

Integration with Other Skills

Combines With:

• git-platform-cli: Get repo URLs for delegation
• code-review: Delegate reviews to testing agent
• test-driven-development: Generate tests via testing agent
• systematic-debugging: Delegate root cause analysis

Example Combined Workflow:

# 1. Get current branch/repo info (git-platform-cli)
REPO_URL=$(git remote get-url origin)
BRANCH=$(git branch --show-current)

# 2. Delegate code review (remote-code-agents)
TASK_ID=$(claude-task submit \
  "Review changes in ${BRANCH} for bugs, security, and performance" \
  --repo "${REPO_URL}" \
  --type testing)

# 3. Continue local work while agent reviews

# 4. Later: Check results
claude-task status ${TASK_ID}

Commitment

When delegating to remote agents, I will:

• Use appropriate agent type for the task
• Provide clear, specific task descriptions
• Configure environment variables, never hardcode credentials
• Inform user when delegating long-running tasks
• Monitor task status for time-sensitive work
• Consider security implications of repository access
• Document task IDs for later reference
• Choose delegation over local execution for resource-intensive work

---

Note: This skill requires external infrastructure. Ensure remote agents are configured and accessible before use.