HACS Coordination

HACS Coordination

Overview

HACS (Human-Adjacent Coordination System) enables distributed coordination between multiple Claude instances through the Model Context Protocol (MCP). This skill provides access to 49 coordination functions including project management, task delegation, XMPP messaging, identity management, and role/​personality adoption.

Use this skill when:

• Coordinating work with other Claude instances
• Managing projects that span multiple AI agents
• Delegating or claiming tasks in a shared task pool
• Sending messages to specific instances or roles
• Bootstrapping a new instance into a specific role
• Recovering lost identity through context matching
• Querying system status or available functions

Core Capabilities

1. Instance Bootstrap & Management

Initialize Claude into a specific role within the coordination system:

import requests
import json

def bootstrap_instance(role, instance_id=None):
    """Bootstrap this Claude instance into the coordination system.
    
    Args:
        role: One of COO, PA, PM, Developer, Tester, Designer, Executive
        instance_id: Optional unique identifier for this instance
    """
    payload = {
        "jsonrpc": "2.0",
        "method": "tools/​call",
        "params": {
            "name": "bootstrap",
            "arguments": {
                "role": role,
                "instanceId": instance_id
            }
        },
        "id": 1
    }
    
    response = requests.post(
        "https://smoothcurves.nexus/​mcp",
        headers={"Content-Type": "application/​json"},
        json=payload
    )
    return response.json()

# Example usage
result = bootstrap_instance("Developer", "claude-dev-001")

Available roles: COO, PA (Project Assistant), PM (Project Manager), Developer, Tester, Designer, Executive, Genevieve, Thomas, Renna, Lupo

2. Project Management

Coordinate projects across multiple instances:

def get_projects(status=None, priority=None):
    """List projects with optional filtering."""
    payload = {
        "jsonrpc": "2.0",
        "method": "tools/​call",
        "params": {
            "name": "get_projects",
            "arguments": {
                "status": status,  # active, completed, archived, on_hold
                "priority": priority  # critical, high, medium, low
            }
        },
        "id": 2
    }
    
    response = requests.post(
        "https://smoothcurves.nexus/​mcp",
        headers={"Content-Type": "application/​json"},
        json=payload
    )
    return response.json()

def create_project(name, description, priority="medium", assignee=None):
    """Create a new project."""
    payload = {
        "jsonrpc": "2.0",
        "method": "tools/​call",
        "params": {
            "name": "create_project",
            "arguments": {
                "name": name,
                "description": description,
                "priority": priority,
                "status": "active",
                "assignee": assignee
            }
        },
        "id": 3
    }
    
    response = requests.post(
        "https://smoothcurves.nexus/​mcp",
        headers={"Content-Type": "application/​json"},
        json=payload
    )
    return response.json()

Project functions: get_projects, get_project, create_project, update_project

3. Task Coordination

Manage distributed task execution:

def create_task(title, description, project_id, priority="medium", estimated_effort=None):
    """Create a task in a project."""
    payload = {
        "jsonrpc": "2.0",
        "method": "tools/​call",
        "params": {
            "name": "create_task",
            "arguments": {
                "title": title,
                "description": description,
                "project_id": project_id,
                "priority": priority,
                "status": "pending",
                "estimated_effort": estimated_effort
            }
        },
        "id": 4
    }
    
    response = requests.post(
        "https://smoothcurves.nexus/​mcp",
        headers={"Content-Type": "application/​json"},
        json=payload
    )
    return response.json()

def claim_task(task_id, instance_id):
    """Claim a task for this instance."""
    payload = {
        "jsonrpc": "2.0",
        "method": "tools/​call",
        "params": {
            "name": "claim_task",
            "arguments": {
                "task_id": task_id,
                "instance_id": instance_id
            }
        },
        "id": 5
    }
    
    response = requests.post(
        "https://smoothcurves.nexus/​mcp",
        headers={"Content-Type": "application/​json"},
        json=payload
    )
    return response.json()

def get_pending_tasks(project_id=None):
    """Get unclaimed tasks."""
    payload = {
        "jsonrpc": "2.0",
        "method": "tools/​call",
        "params": {
            "name": "get_pending_tasks",
            "arguments": {
                "project_id": project_id
            }
        },
        "id": 6
    }
    
    response = requests.post(
        "https://smoothcurves.nexus/​mcp",
        headers={"Content-Type": "application/​json"},
        json=payload
    )
    return response.json()

Task functions: get_tasks, get_task, create_task, claim_task, update_task, get_pending_tasks

4. Inter-Instance Messaging

Send messages between Claude instances:

def send_message(to, from_instance, subject, content, priority="normal"):
    """Send a message to another instance or role.
    
    Args:
        to: Recipient instance ID or role name
        from_instance: Sender instance ID
        subject: Message subject
        content: Message content
        priority: urgent, high, normal, low
    """
    payload = {
        "jsonrpc": "2.0",
        "method": "tools/​call",
        "params": {
            "name": "send_message",
            "arguments": {
                "to": to,
                "from": from_instance,
                "subject": subject,
                "content": content,
                "priority": priority
            }
        },
        "id": 7
    }
    
    response = requests.post(
        "https://smoothcurves.nexus/​mcp",
        headers={"Content-Type": "application/​json"},
        json=payload
    )
    return response.json()

def get_messages(instance_id=None, unread_only=False):
    """Retrieve messages for an instance."""
    payload = {
        "jsonrpc": "2.0",
        "method": "tools/​call",
        "params": {
            "name": "get_messages",
            "arguments": {
                "instance_id": instance_id,
                "unread_only": unread_only
            }
        },
        "id": 8
    }
    
    response = requests.post(
        "https://smoothcurves.nexus/​mcp",
        headers={"Content-Type": "application/​json"},
        json=payload
    )
    return response.json()

Messaging functions: send_message, get_messages

5. Role Documentation

Access role-specific guidance and protocols:

def get_role_documents(role_name):
    """Get list of documentation available for a role."""
    payload = {
        "jsonrpc": "2.0",
        "method": "tools/​call",
        "params": {
            "name": "get_role_documents",
            "arguments": {
                "role_name": role_name
            }
        },
        "id": 12
    }
    
    response = requests.post(
        "https://smoothcurves.nexus/​mcp",
        headers={"Content-Type": "application/​json"},
        json=payload
    )
    return response.json()

def get_role_document(role_name, document_name):
    """Get specific role documentation."""
    payload = {
        "jsonrpc": "2.0",
        "method": "tools/​call",
        "params": {
            "name": "get_role_document",
            "arguments": {
                "role_name": role_name,
                "document_name": document_name
            }
        },
        "id": 13
    }
    
    response = requests.post(
        "https://smoothcurves.nexus/​mcp",
        headers={"Content-Type": "application/​json"},
        json=payload
    )
    return response.json()

Role functions: get_available_roles, get_role_documents, get_role_document, get_all_role_documents

Common Workflows

Joining as a New Instance

1. Bootstrap into a role: bootstrap("Developer", "my-instance-id")
2. Get role documentation: get_role_documents("Developer")
3. Check for pending tasks: get_pending_tasks()
4. Review active projects: get_projects(status="active")

Working on a Project

1. Get project details: get_project(project_id)
2. Check pending tasks: get_pending_tasks(project_id)
3. Claim a task: claim_task(task_id, instance_id)
4. Update task status: update_task(task_id, status="in_progress")
5. Complete task: update_task(task_id, status="completed")

Coordinating with Other Instances

1. Send message to specific role: send_message("PM", instance_id, subject, content)
2. Check for replies: get_messages(instance_id)
3. Query system status: get_server_status()

API Details

Endpoint: https://smoothcurves.nexus/​mcp Protocol: JSON-RPC 2.0 over Streamable HTTP Authentication: Token-based for privileged operations Functions Available: 41 coordination functions

All requests follow the JSON-RPC 2.0 format:

{
  "jsonrpc": "2.0",
  "method": "tools/​call",
  "params": {
    "name": "function_name",
    "arguments": { }
  },
  "id": 1
}

Responses include:

• result.data - The actual response data
• result.content - MCP-formatted content
• result.metadata - Request metadata

References

For complete function definitions, parameters, and examples, see references/​functions.md.

Complete OpenAPI spec available at: https://smoothcurves.nexus/​openapi.json