HCT Signal Specification

The Standard for Agentic Coordination

[!IMPORTANT] Status: Public Preview
This specification defines the wire format and semantics for Harmonic Coordination Theory (HCT) signals.
The canonical schema definition is maintained in hct-spec.

1. Introduction

Frameworks like MCP and A2A excel at connecting agents to tools, but they lack a shared vocabulary for coordination. Without standardized signals, developers are forced to build ad-hoc state machines for urgency, approval gates, and synchronization.

HCT Signals provide a universal layer for agent orchestration, modeled after musical dynamics and temporal markings. This specification defines the data structures that allow agents to express how a task should be executed, not just what to do.

It is based on the research presented in Harmonic Coordination Theory, extending the "musical ontology" concept into a concrete wire protocol.

Core Primitives

Signals: Seven distinct coordination intents (e.g., CUE for action, FERMATA for holding).
Tempo: Latency and urgency expectations.
Dynamics: Resource intensity and compute budget.

2. Signal Definitions

The protocol defines 7 mutually exclusive signal types.

`CUE` (Action)

Semantics: Trigger immediate activation or handoff. Use this to dispatch tasks or pass control.
Behavior: Receiver MUST accept the task or reject immediately.

`FERMATA` (Hold)

Semantics: Pause execution indefinitely until an external condition is met.
Use Case: Human-in-the-loop approval, governance checks, waiting for resources.
Fields:

hold_type: human, governance, resource, quality

`ATTACCA` (Transition)

Semantics: Proceed immediately to the next movement/task without pause.
Use Case: Latency-critical pipelines, real-time voice interruptions.
Behavior: Bypasses standard queue processing; prioritized handling.

`VAMP` (Loop)

Semantics: Repeat a sequence until a specific condition is satisfied.
Use Case: Polling an API, self-correction loops, quality assurance retries.
Fields:

repeat_until: Condition string (e.g., "quality > 0.9")

`CAESURA` (Stop)

Semantics: A sudden, full stop. Abrupt silence.
Use Case: Emergency shutdown, circuit breaking, canceling a hallucinating agent.

`TACET` (Silence)

Semantics: The agent is explicitly silent/inactive for a duration.
Use Case: Resource conservation, putting a "listener" agent to sleep.

`DOWNBEAT` (Sync)

Semantics: A global synchronization point.
Use Case: Barrier synchronization where multiple agents must arrive before any proceed.

3. Performance Parameters

Signals are modified by performance parameters that dictate execution constraints.

Tempo (Urgency)

Controls the expected latency and priority of the operation.

Marking	Priority	Latency Target	Use Case
Largo	Batch	~60s	Background analysis, deeply thoughtful & slow.
Andante	Low	~30s	Walking pace. Standard non-blocking tasks.
Moderato	Normal	~15s	Default. Standard interactive response.
Allegro	High	~5s	Fast. User is waiting (e.g., loading spinner).
Presto	Real-time	~1s	Voice/Chat generation. Drop quality for speed.

Dynamics (Intensity)

Controls the resource consumption and model power.

Marking	Multiplier	Model Class	Use Case
pp (Pianissimo)	0.25x	Nano / Flash	Cache lookup, routing, simple classifying.
p (Piano)	0.5x	Small / Turbo	Standard refactoring, basic code gen.
mf (Mezzo-Forte)	1.0x	Medium	Default. Balanced reasoning.
f (Forte)	1.5x	Large / Opus	Complex reasoning, creative writing.
ff (Fortissimo)	2.0x	O1 / Reasoning	Deep research, architectural planning.

4. Schema Reference

The HCT payload is designed to be embedded in host protocols (MCP, A2A).

{
  "hct_signal": {
    "type": "cue",           // [Required] One of: cue, fermata, attacca, vamp, ...
    "source": "orchestrator",
    "targets": ["analyst"],
    
    "performance": {
      "urgency": 8,          // Integer 1-10
      "tempo": "allegro",    // Enum: largo, andante, moderato, allegro, presto
      "dynamics": "mf",      // Enum: pp, p, mf, f, ff
      "timeout_ms": 5000
    },

    "conditions": {
      "hold_type": "human",         // For FERMATA
      "quality_threshold": 0.9,     // For VAMP
      "repeat_until": "score > 0.9" // For VAMP
    },

    "context": {
      "movement": "refinement_phase",
      "objectives": ["improve_coverage"]
    }
  }
}

[!TIP] View Full Schema
The definitive JSON Schema is available here:
hct-spec/schema.json

5. Protocol Bindings

Model Context Protocol (MCP)

HCT signals are embedded in standard MCP JSON-RPC messages. Agents negotiate support during initialization.

1. Capability Negotiation Clients and Servers declare support in initialize:

{
  "capabilities": {
    "experimental": {
      "hct_signals": { "version": "1.0" }
    }
  }
}

2. Request Structure (tasks/send) The hct_signal object is injected into the params.

{
  "jsonrpc": "2.0",
  "method": "tasks/send",
  "params": {
    "id": "123",
    "message": "Analyze dataset.csv",
    "hct_signal": {
      "type": "cue",
      "performance": { 
        "tempo": "presto",
        "urgency": 9
      }
    }
  }
}

Agent-to-Agent Protocol (A2A)

For A2A, HCT is implemented as a Protobuf extension.

import "hct/v1/hct.proto";

message TaskRequest {
  string task_id = 1;
  // ... standard fields ...
  hct.v1.HctSignal hct_signal = 100; // Extension field
}

6. Implementation Guide

We provide official SDKs generated from the canonical spec.

Python

pip install hct-mcp-signals

from hct_mcp_signals import cue, Tempo

# Create a high-urgency signal
signal = cue("orch", ["agent_a"], urgency=9, tempo=Tempo.PRESTO)

# Attach to MCP call
mcp.send_request("analyze", hct_signal=signal.to_dict())

TypeScript

npm install @hct-mcp/signals

import { cue, Tempo } from '@hct-mcp/signals';

const signal = cue({
  source: 'orch',
  targets: ['agent_a'],
  tempo: Tempo.PRESTO
});

Rust

cargo add hct-mcp-signals

use hct_mcp_signals::{cue, Tempo};

// Builder pattern for type-safe construction
let signal = cue("orch", vec!["agent_a"])
    .with_urgency(9)
    .with_tempo(Tempo::Presto)
    .build();

Go

go get github.com/stefanwiest/hct-mcp-signals/go

import "github.com/stefanwiest/hct-mcp-signals/go"

sig := hct.NewCue("orch", []string{"agent_a"}).
    WithTempo(hct.TempoPresto)

7. Versioning & Compatibility

Current Version: 1.0.0
Versioning Strategy: Semantic Versioning. Changes to spec.yaml trigger minor or major version bumps in all downstream SDKs.
Forward Compatibility: Parsers MUST ignore unknown fields in the hct_signal object.
Discovery: Agents SHOULD advertise hct_signals: true in their capabilities handshake.

8. Development

The HCT specification is maintained in a central repository.

Repository: stefanwiest/hct-spec
Issues: Please file spec bugs or RFC proposals in the hct-spec repo.

9. References

Harmonic Coordination Theory: The foundational paper establishing the musical ontology for Multi-Agent Systems.
The 97% Scaling Problem: Why traditional orchestration fails at scale.

Read the Paper ↗ View Source (GitHub)