Spaces:
Running
title: SignalMesh — Ambient Context Protocol for AI Agent Fleets
emoji: 📡
colorFrom: pink
colorTo: yellow
sdk: docker
app_port: 7860
pinned: true
tags:
- ai-agents
- llm
- multi-agent
- context-protocol
- no-tool-calls
- broadcast
- ambient-context
- agent-infrastructure
- signalmesh
- sovereign-liquid-matrix
📡 SignalMesh
Context finds the agent. Not the other way around.
SignalMesh is an ambient context protocol for LLM multi-agent systems. It eliminates the overhead of read-only tool calls by inverting the context-acquisition model: instead of agents polling for information, information is broadcast onto spatial frequencies that agents passively receive.
🌐 Live API (hosted)
The mesh is live and hosted — you don't need to run it locally to integrate:
Base URL: https://acecalisto3-signalmesh.hf.space
Auth: X-SignalMesh-Key: smesh-free-demo (free tier · 200 calls / 24h)
Docs: https://acecalisto3-signalmesh.hf.space/docs
Chat with the mesh — POST /api/chat answers a message with multi-provider
failover (groq → gemini → opencode_zen → huggingface → xai), hydrated with live
mesh context. No per-app provider keys required:
curl -X POST https://acecalisto3-signalmesh.hf.space/api/chat \
-H "X-SignalMesh-Key: smesh-free-demo" \
-H "Content-Type: application/json" \
-d '{"session_id":"demo","message":"What can the mesh do?"}'
# → {"reply":"...","provider":"groq:llama-3.1-8b-instant","active_signals":[...],"history_len":1}
Tune in / broadcast against the live mesh:
curl -X POST https://acecalisto3-signalmesh.hf.space/api/tune_in \
-H "X-SignalMesh-Key: smesh-free-demo" -H "Content-Type: application/json" \
-d '{"keywords":["ai-engineer","python-pro"]}'
curl -X POST https://acecalisto3-signalmesh.hf.space/api/broadcast \
-H "X-SignalMesh-Key: smesh-free-demo" -H "Content-Type: application/json" \
-d '{"frequency":"my_agent","content":"hello mesh","source_type":"demo"}'
The
localhost:7475examples further down are for local development. For hosted use, swap in the Base URL above.
The Problem with Current Multi-Agent Frameworks
Every major agent framework today — LangGraph, AutoGen, CrewAI, OpenManus — treats context acquisition as a tool call:
Agent: "I need to know the current system errors."
→ calls get_system_errors() [+1 inference round-trip]
Agent: "I need the architecture patterns."
→ calls get_architecture_docs() [+1 inference round-trip]
Agent: "I need active signal feeds."
→ calls get_active_signals() [+1 inference round-trip]
Agent: "Now I can work."
Each tool call costs:
- 1 extra LLM inference invocation (~$0.001–0.01, ~800ms latency)
- Tool schema tokens injected into every context window (~80 tok/tool)
- Call/result wrapper overhead per invocation (~40 tok/call)
- Sequential blocking — agents wait for each fetch before proceeding
In a fleet of 5 agents each needing 3 context fetches, this overhead compounds to 4,200 wasted scaffold tokens and 25 eliminated inference calls.
The Antennae Model
SignalMesh inverts this with three primitives:
[Data Source: logs, RSS, agent outputs]
│
▼
signal_registry.broadcast("frequency_name", content)
│
├──► Agent A: tune_in(["python-pro", "error"]) ← catches it
├──► Agent B: tune_in(["architecture"]) ← catches it
└──► Agent C: tune_in(["financial"]) ← misses (wrong freq)
Agents are antennae, not search engines. Context arrives at their frequency. No tool call. No round-trip. No schema overhead. The framework intercepts the system prompt before execution and hydrates it with matched signals.
Benchmark
Identical informational content, measured across both modes.
Token approximation: len(string) / 4 (consistent; delta is exact).
| Metric | Tool-Call Mode | SignalMesh Mode | Delta |
|---|---|---|---|
| Total context tokens | 514 | 266 | ▼48% |
| Scaffolding overhead tokens | 280 | 34 | ▼88% |
| — Schema definitions | 168 | 0 | ▼100% |
| — Call/result wrappers | 112 | 0 | ▼100% |
| Inference round-trips | 2 | 1 | ▼50% |
| Tool calls fired | 3 | 0 | ▼100% |
tune_in() latency |
n/a | 1.69 µs | — |
Fleet projection (5 agents × 3 context fetches each):
| Metric | Tool-Call | SignalMesh | Savings |
|---|---|---|---|
| Overhead tokens (fleet) | 4,200 | 170 | −4,030 tok |
| Inference trips | 30 | 5 | −25 trips |
| Overhead reduction | — | — | 96% |
Run
python signalmesh_benchmark.pyto reproduce on your hardware.
Three Named Innovations
1. The Antennae Model
Agents declare their frequency via keywords (id, cluster, name).
The framework calls tune_in(keywords) before each agent invocation and
appends matched signals to the system prompt. Zero explicit tool calls
for read-only context.
2. Spatial Signal Indexing
A 9×8 grid (72 nodes) maps agent roles by cluster row and seniority column. External URIs are hashed via SHA-256 and mapped to the nearest grid node, deterministically routing live data to the most relevant agent domain. No vector database, no embedding inference — sub-millisecond lookup via Python dict.
SHA-256(uri) % 72 → (row, col) → agent keyword → prompt hydration
Grid layout (54 agents, 72 nodes):
Col0 Col1 Col2 ... Col7
Row0: backend-arch frontend-dev mobile ... [overflow] ← ARC cluster
Row1: python-pro javascript golang ... physics-sim ← LEG cluster
Row2: cloud-arch terraform network ... [overflow] ← INF cluster
Row3: devops incident-res db-adm ... [overflow] ← OPS cluster
Row4: ai-engineer ml-engineer mlops ... [empty] ← DATA cluster
Row5: security-aud hardening review ... [empty] ← QUAL cluster
Row6: biz-analyst quant risk ... [empty] ← BIZ cluster
Row7: content-mkt sales-auto support ... [empty] ← GROW cluster
Row8: context-mgr prompt-eng search ... [empty] ← UTIL cluster
3. Frequency Gate Protocol
Broadcasts on sensitive frequencies (security_*, sql_*, auth_*, key_*)
are staged into a quarantine buffer rather than committed to the live mesh.
A designated SEC-Ω warden reviews before any signal propagates.
Trust is a first-class property of the broadcast path.
# Sensitive broadcast → quarantine, not live mesh
signal_broadcast.execute(topic="security_vulns", content="CVE-2024-XYZ found")
# → staged at sec_quarantine_security_vulns
# → SEC-Ω approves: signal_broadcast.execute(..., bypass_gate=True)
Architecture
┌─────────────────────────────────────────────────────────────────┐
│ SignalMesh │
│ │
│ [Sources] [Registry] [Antennae] │
│ │
│ Logger.ERROR ───► broadcast() ◄─── RSS/API feeds │
│ Agent outputs ───► │ ◄─── Context discovery │
│ │ │
│ tune_in(keywords) ← 1.69 µs avg │
│ │ │
│ ┌─────────┴──────────┐ │
│ System Prompt Grid Node │
│ (hydrated, (spatial_index.json) │
│ zero tool calls) │
│ │
│ [Gate] SEC-Ω quarantine for protected frequencies │
└─────────────────────────────────────────────────────────────────┘
Quickstart
# Clone
git clone https://github.com/Ig0tU/SignalMesh
cd SignalMesh
# Run the integration test (no LLM required)
python demo_signal_mesh_action.py
# Run the benchmark
python signalmesh_benchmark.py
# Launch the live web visualiser
python signalmesh_viz_server.py
# → open http://localhost:7474
# Inspect the spatial grid layout
python utils/spatial_grid.py --visualize
File Map
core/
├── signal_registry.py # Singleton broadcast/tune-in hub
└── spatial_grid.py # 9×8 SHA-256 URI indexer
tools/
├── context_discovery.py # Auto-scan workspace for feed URLs
├── rss_matrix_sync.py # RSS → spatial grid node sync
└── signal_broadcast.py # Agent write-back with SEC-Ω gate
agents/
└── matrix_agents.py # Dynamic ToolCallAgent antennae
marketing/
└── visual_scan.py # Live grid visualiser (terminal + web)
signalmesh_benchmark.py # Reproducible benchmark (no API key needed)
signalmesh_viz_server.py # FastAPI live grid server (port 7474)
signalmesh_viz.html # Web UI — real-time pulsing grid
demo_signal_mesh_action.py # Full 5-phase integration smoke test
Comparison with Related Work
| Approach | Context Delivery | Overhead | Latency |
|---|---|---|---|
| LangGraph tool nodes | Explicit tool call | High (schema + call + result) | ~800ms API |
| LlamaIndex RAG | Query-time retrieval | Medium (embedding inference) | ~100ms |
| AutoGen context vars | Manual orchestrator injection | Low | ~0ms |
| MemGPT archival memory | Paged memory retrieval | Medium (LLM-driven) | ~500ms |
| SignalMesh | Ambient broadcast | Minimal (34 tok formatting) | 1.69 µs |
Key distinction from AutoGen context variables: SignalMesh is bidirectional.
Agents are both consumers (tune_in) and producers (broadcast) — any agent
can update the ambient context available to all others. AutoGen variables are
set by the orchestrator only. SignalMesh creates a self-updating intelligence loop.
External API — SLM Gateway
SignalMesh exposes a REST API so external AI systems can join the Sovereign Liquid Matrix — broadcasting signals in and tuning into live ambient context without running their own mesh.
# Install deps
pip install fastapi uvicorn
# Start the gateway
python signalmesh_api.py
# → http://localhost:7475
# → interactive docs at http://localhost:7475/docs
30-second integration:
# Tune in — get hydrated context for your agent's system prompt
curl -X POST http://localhost:7475/api/tune_in \
-H "X-SignalMesh-Key: slm-dev-key-2026" \
-H "Content-Type: application/json" \
-d '{"keywords": ["ai-engineer", "python-pro"]}'
# Broadcast a signal onto the mesh
curl -X POST http://localhost:7475/api/broadcast \
-H "X-SignalMesh-Key: slm-dev-key-2026" \
-H "Content-Type: application/json" \
-d '{"frequency": "python-pro", "content": "Your agent finding here"}'
See SLM_INTEGRATION.md for the full integration guide, frequency naming conventions, SEC-Ω trust tiers, and production access.
For the philosophy behind the architecture: SIGNAL_MANIFESTO.md
Citation
@misc{signalmesh2026,
title = {Active Antennae: Ambient Context Hydration for LLM Agent Networks
Without Tool Overhead},
year = {2026},
url = {https://github.com/Ig0tU/SignalMesh},
}
📡 Context finds the agent.