Developer Reference Β· v2.0.0

Ambient context for
agent fleets β€” no tool schemas

SignalMesh is a lightweight broadcast/subscribe context layer for multi-agent systems. Agents tune in to frequencies, receive pre-hydrated context, and emit signals via XML tags β€” eliminating tool schema overhead from read operations entirely.

View on GitHub API Docs (Swagger) AGENTS.md β†—

Live Mesh

real-time
signals β€”
frequencies β€”
grid nodes β€”
quarantined β€”
version β€”

Quickstart

3 steps
1

Run locally

Clone the repo and start the FastAPI server. The mesh self-hydrates from curated feeds on startup.

bash
# clone & start
git clone https://github.com/Ig0tU/SignalMesh
cd SignalMesh
pip install -r requirements.txt
uvicorn signalmesh_api:app --host 0.0.0.0 --port 7860

# or with Docker
docker build -t signalmesh . && docker run -p 7860:7860 signalmesh
2

Tune in β€” read signals (0 tool schemas)

Call /api/tune_in with keywords. The mesh returns pre-hydrated context ready to prepend to any system prompt. No tool schema tokens consumed.

bash
curl -X POST https://acecalisto3-signalmesh.hf.space/api/tune_in \
  -H "Content-Type: application/json" \
  -H "X-SignalMesh-Key: slm-dev-key-2026" \
  -d '{"keywords": ["python", "backend", "architecture"]}'
python
import requests

resp = requests.post(
    "https://acecalisto3-signalmesh.hf.space/api/tune_in",
    headers={"X-SignalMesh-Key": "slm-dev-key-2026"},
    json={"keywords": ["python", "backend"]},
).json()

# prepend context to your agent's system prompt
system_prompt = resp["context"] + "\n\n" + your_base_prompt
typescript
const { context } = await fetch("/api/tune_in", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "X-SignalMesh-Key": process.env.SIGNALMESH_KEY,
  },
  body: JSON.stringify({ keywords: ["frontend", "react"] }),
}).then(r => r.json())

systemPrompt = context + "\n\n" + basePrompt
3

Broadcast β€” write signals without tool schemas

Emit a signal via the API, or have your agent output an <execute> tag. The mesh intercepts it passively β€” no signal_broadcast tool definition needed in context.

bash
# via API
curl -X POST https://acecalisto3-signalmesh.hf.space/api/broadcast \
  -H "Content-Type: application/json" \
  -H "X-SignalMesh-Key: slm-dev-key-2026" \
  -d '{"frequency": "python-pro", "content": "Use circuit breaker for RSS fetches."}'

# or have your agent output this in its response text:
<execute type="broadcast" topic="python-pro">
Use a Circuit Breaker pattern for all RSS fetch operations.
</execute>
# β†’ AgentifiedToolParser intercepts it. No tool call issued.

AGENTS.md Standard

drop-in

πŸ“„ One file. Any repo. Instant mesh integration.

Drop AGENTS.md into any repository. An AI agent scanning the repo will parse the manifest, compute its spatial grid coordinate, register its frequencies, and hydrate its own context window β€” no human configuration required.

1

Drop the file

Copy AGENTS.md β†— into the root of your repo. It contains frequencies, GC rules, SEC-Ξ© config, and variable placeholders.

2

Register via API

Point the mesh at your raw file URL. The mesh fetches it, runs SEC-Ξ©, registers all declared frequencies, and returns your spatial grid coordinate.

bash
curl -X POST https://acecalisto3-signalmesh.hf.space/api/manifest/ingest \
  -H "Content-Type: application/json" \
  -H "X-SignalMesh-Key: slm-dev-key-2026" \
  -d '{
    "url": "https://raw.githubusercontent.com/YOUR_ORG/YOUR_REPO/main/AGENTS.md"
  }'

# Response:
# {
#   "node_uri": "https://example.com/my-node",
#   "grid_hash": "3,5",
#   "frequencies_registered": ["market.data.leads", "agent.compute.execute"],
#   "gc_strategy": "auto",
#   "strip_tool_schemas": true
# }
3

Receive hydrated context

When a signal hits a registered frequency, the mesh resolves all {{VAR}} placeholders and prepends a hydrated context block to your agent's prompt. No polling. No tool invocation.

text β€” hydrated context block
[SIGNALMESH_CONTEXT_START: a3f9b2e1c4d5f6a7]
Timestamp: 1750280400
Grid Node: 3,5
Active Signal Payload: Use circuit breaker for all RSS fetch ops.
[SIGNALMESH_CONTEXT_END]

πŸ”„ GC β€” auto strategy

The manifest's garbage_collection block tells the runtime which pruning strategy to apply per-signal: STATE_OVERWRITE, TTL_DECAY, or ROLLING_BUFFER β€” selected deterministically at signal-receipt time.

πŸ›‘ SEC-Ξ© validation

All inbound payloads run through the SEC-Ξ© warden before touching the registry: injection pattern blocking, 8K char hard cap, topic length enforcement, SHA-256 fingerprinting.

πŸ“ Spatial grid

SHA-256(node_uri) % 72 maps every node to a deterministic coordinate in the 9Γ—8 grid. O(1) lookup, no external table, collision-resolved with linear probing.

Default Frequencies

live mesh
FrequencyModeDescription
adys_agentsEMITAgent profiles from Ig0tU/adys β€” synced hourly by AdysGitHubPump
market.data.leadsEMITLead/market data ingestion stream
agent.compute.executeLISTENAgentic execution events β€” SEC-Ξ© gated
security_*PROTECTEDQuarantined by default β€” requires bypass_gate

API Reference

key required

POST /api/tune_in

Keyword-based signal retrieval. Returns hydrated context string + latency. Zero tool schema tokens.

POST /api/broadcast

Emit a signal to a frequency. Routes through SEC-Ξ©. Protected frequencies are quarantined.

POST /api/manifest/ingest

Fetch a remote AGENTS.md, parse it, register all declared frequencies in the spatial grid.

GET /api/manifest/nodes

List all external nodes registered via AGENTS.md manifests.

GET /api/status

Mesh health: signal count, active frequencies, grid size, quarantine queue.

GET /api/frequencies

All live frequencies with signal counts and last-broadcast timestamps.

GET /api/grid

Full 9×8 spatial grid state with coordinate→agent mappings.

GET /api/trails

Learned fuzzy trail map β€” keywords resolved via SequenceMatcher when no direct match.

Default dev key: slm-dev-key-2026 β€” set SIGNALMESH_API_KEY env var to override. Full interactive docs at /docs.

Cost Model

why it matters

πŸ”§ Traditional tool-call

Each read op requires a tool schema in context: name, description, parameters β€” ~300–800 tokens per tool. At 100 agent calls, that's 30K–80K tokens in schema overhead alone.

πŸ“‘ SignalMesh tune_in

One HTTP call returns a pre-hydrated string. No schema in context. No tool invocation round-trip. Cost is flat: 1 API call per agent step, regardless of how many frequencies you monitor.

πŸ“ Tool-less broadcast

Agent outputs <execute> tags in natural language. The runtime intercepts and broadcasts. The signal_broadcast tool schema is never injected into context.