Why

Multi-agent systems built on LLMs fail in characteristic ways: context collapse, where every signal is forwarded to every agent until the window saturates with noise; context rot, where stale or redundant information displaces what matters; and cascade failures, where one agent's hallucination propagates unchecked through downstream calls. The industry patches these with longer prompts and ad-hoc orchestration glue.

The brain does not hand every sensation to the cortex. The thalamus gates sensory input before it reaches higher regions. The prefrontal cortex decides what is currently relevant. Sparse coding keeps most neurons quiet, most of the time. Autonomous agents (runtimes like Nous Research's Hermes) have no structural equivalent, so SGP provides one: a layer of typed signals, composable gates, autonomous agents, and meshes that sits between the agents producing signals and the agents consuming them.

Primitives

`Signal`

Typed, immutable events. Subclass Signal to define your domain; each carries a priority and metadata. Derive new signals with evolve() instead of mutating, so provenance stays intact.

`Gate`

Composable predicates that control which signals an agent sees. Combine with >> (chain), | (or), & (and), ~ (invert). Built-ins include by_priority, deduplicate, throttle, ttl, when, and circuit_breaker.

`Agent`

Autonomous signal processors. Handle signals with @agent.on(...), emit/reply/request between agents, expose tools, and auto-restart under supervision. An agent is where a runtime like Hermes plugs in.

`Mesh`

Agent network topology. Wire agents with connect, then coordinate with scatter, map_reduce, workflow, and race: multi-agent patterns without hard-coding call graphs.

Code

Real, runnable code from the alpha SDK. Two agents wired through a mesh: the worker only ever sees high-priority tasks, gated on the way in.

python

import asyncio
from signal_gating import Signal, Gate, Agent, Mesh

class TaskSignal(Signal):
    task: str

planner = Agent("planner")
worker = Agent("worker", gates=[Gate.by_priority(3)])  # low-priority tasks never reach it

@worker.on(TaskSignal)
async def handle(signal: TaskSignal):
    print(f"working on: {signal.task}")

mesh = Mesh([planner, worker])
mesh.connect(planner, worker)

async def main():
    async with mesh:
        await planner.emit(TaskSignal(task="build feature", priority=5))
        await asyncio.sleep(0.05)

asyncio.run(main())

The executive-function layer for autonomous AI.

Why