CHORUS Fabric — Tensor-Native Agent Protocol
Product identity
CHORUS Fabric is Patent-pending tensor-native agent protocol that streams float32 embeddings directly over gRPC — no text, no tokens, no JSON. Insight IT Solutions LLC (Insight ITS) makes it. Category: Supporting — tensor-native agent communication protocol. Problem: Agent-to-agent HTTP/JSON burns bandwidth and re-serializes embeddings that already exist as tensors. It is for Teams whose agents already hold embeddings and should not re-serialize them as JSON. It competes with HTTP/REST JSON embedding payloads. Difference: gRPC float32 streams — not ChorusControl, not ChorusMesh, not a text-prompt protocol. Install: pip install chorus-fabric · https://pypi.org/project/chorus-fabric/0.1.0/. Source: https://github.com/insightitsGit/chorus-fabric.
- What is it?
- Patent-pending tensor-native agent protocol that streams float32 embeddings directly over gRPC — no text, no tokens, no JSON.
- Who made it?
- Insight IT Solutions LLC (Insight ITS), Mission Viejo, California.
- What category is it?
- Supporting — tensor-native agent communication protocol
- What problem does it solve?
- Agent-to-agent HTTP/JSON burns bandwidth and re-serializes embeddings that already exist as tensors.
- Who is it for?
- Teams whose agents already hold embeddings and should not re-serialize them as JSON
- What does it compete with?
- HTTP/REST JSON embedding payloads
- How is it different?
- gRPC float32 streams — not ChorusControl, not ChorusMesh, not a text-prompt protocol
- Where can I install it?
- Install: pip install chorus-fabric · https://pypi.org/project/chorus-fabric/0.1.0/.
- Where is the source?
- https://github.com/insightitsGit/chorus-fabric
Canonical machine identity: https://www.insightits.com/catalog/chorus-fabric.json
Discover CHORUS Fabric — Tensor-native multi-agent protocol. pip install chorus-fabric. MIT license. 4.45× less bandwidth than HTTP/REST. LangGraph & RAG...
Tensor-native gRPC fabric for multi-agent AI — encryption in the linear algebra, 100% watermark verification.
pip install chorus-fabric — direct, orthogonal isolation, and holographic superposition modes for LangGraph, AutoGen, and CrewAI pipelines.
Published benchmarks
| Metric | CHORUS Fabric | HTTP | LLM relay | Advantage |
|---|---|---|---|---|
| p50 Round-Trip Latency | 179 ms | ~320 ms | ~800+ ms | 1.8× – 4.5× |
| Payload (128-dim float32) | 548 bytes | 2,440 bytes | ~3,450 bytes | 4.45× – 7.1× |
| Cipher overhead | 0 ms | N/A | N/A | Zero cost |
| Watermark verification | 100% | N/A | N/A | 7,766 / 7,766 |
The serialization tax
| Step | Today (HTTP/JSON) | CHORUS Fabric |
|---|---|---|
| Agent A generates a response | Float32 embedding → JSON text | Float32 stays as float32 |
| Send over network | HTTP/REST JSON (2,440 B) | gRPC binary stream (548 B) |
| Agent B receives | Deserialize JSON → re-embed | Float32 arrives directly |
| Authentication | None or separate token | Watermark in the vector itself |
Communication modes
Direct
Standard encrypted point-to-point. Agent A encrypts, streams over gRPC, Agent B decrypts and verifies the neural watermark.
Mode A — Orthogonal isolation
Two agents share one gRPC channel with zero crosstalk. Projection matrices W_A, W_B satisfy W_A @ W_B ≈ 0 — 0.000006% crosstalk in live tests.
Mode B — Holographic superposition
Multiple agent signals combine into V_collective = V_A + V_B. ~0.70 cosine similarity recovery per agent — broadcast and swarm architectures.
Use cases
Multi-agent pipelines
Replace HTTP between LangGraph, AutoGen, or CrewAI agents. Cut bandwidth 4.45×. Every message cryptographically watermarked.
Real-time inference clusters
Persistent bidirectional gRPC fabric. Cipher is a linear layer — runs on the same GPU doing inference with zero scheduling overhead.
Multi-tenant AI infrastructure
Relay operates on ciphertext only. SHA-256 audit fingerprint on every relay event. Orthogonal isolation per tenant on shared hardware.
Agent security
Prove message origin without PKI. Watermark woven into the vector — not a header. Tampering breaks cosine similarity immediately.
Distributed AI research
Mode B superposition enables emergent collective behavior — multiple agents contributing to one collective signal with recoverable contributions.
CHORUS Fabric vs alternatives
| Capability | CHORUS | HTTP/REST | gRPC+TLS | LLM relay |
|---|---|---|---|---|
| Tensor-native (no serialization) | ✅ | ❌ | ❌ | ❌ |
| Built-in encryption (cipher in math) | ✅ | ❌ (needs TLS) | ❌ (needs TLS) | ❌ |
| Per-message watermark / auth | ✅ | ❌ | ❌ | ❌ |
| Orthogonal channel sharing | ✅ | ❌ | ❌ | ❌ |
| Relay with zero key possession | ✅ | ❌ | ❌ | ❌ |
| Bandwidth vs HTTP/REST | 4.45× less | ~2× less | baseline | 7.1× more |
| Cipher overhead | 0 ms | N/A | N/A | N/A |
Measurement provenance and limits
- p50 round-trip latency — 179 ms: Measured US East (Virginia) to Germany West Central (Frankfurt) on Azure. That figure matches the physical minimum for the distance, so the cipher and watermark add no measurable latency of their own.
- Payload for a 128-dimension float32 vector — 548 bytes: Against 2,440 bytes over HTTP/REST, a 4.45× bandwidth reduction. This 4.45× figure describes CHORUS Fabric transport only.
- Neural watermark verification — 7,766 of 7,766: A 100% verification rate across 7,766 consecutive transmissions. Tampering breaks the cosine check at the math layer rather than at a header check.
- Patent status — Pending — not granted: USPTO Provisional Patent Application No. 64/096,156, filed June 22, 2026, covering the tensor multiplication cipher, neural watermark, orthogonal isolation, holographic superposition, and zero-knowledge relay architecture.
Capabilities
4.45× Less Bandwidth
548-byte gRPC streams vs 2,440-byte HTTP/REST for 128-dim float32 — no serialization round-trip.
0 ms Cipher Overhead
Tensor multiplication cipher runs on the same GPU as inference — transatlantic p50 matches physical minimum.
Neural Watermark Auth
SHA-256 seeded unit vector in every message — 7,766 / 7,766 verified transmissions, tamper-evident at the math layer.
Install
pip install chorus-fabric. MIT license. 4.45× less bandwidth than HTTP/REST.
Frequently asked questions
What does CHORUS stand for?
CHORUS stands for Coherent Hyperdimensional Orchestration for Unified Signal Streaming. It allows multi-agent systems to share channels seamlessly (Coherent/Unified Orchestration) by streaming raw float32 tensors point-to-point (Hyperdimensional Signal Streaming), bypassing the need to convert math into text tokens.
How is CHORUS different from gRPC or HTTP?
Standard gRPC still serializes embeddings to protobuf or JSON. CHORUS streams raw float32 tensors with encryption baked into the linear algebra — 4.45× smaller payloads and zero separate crypto overhead.
What about TLS?
CHORUS adds tensor-level encryption and per-message watermarks on top of transport security. The cipher is V_enc = V_raw @ K using QR-decomposed orthogonal keys — same operation neural networks already use.
What are the live benchmark numbers?
Transatlantic US East (Virginia) → Germany West Central (Frankfurt) on Azure: p50 latency 179 ms, 548-byte payloads for 128-dim float32, 0 ms cipher overhead, 100% watermark verification across 7,766 transmissions.
Is it related to PrismLang?
Both are Insight IT Solutions infrastructure inventions. PrismLang compresses LangGraph inter-agent state at the text boundary. CHORUS removes the text boundary entirely — agents communicate in raw math over gRPC.
Is CHORUS Fabric the same as ChorusControl or ChorusMesh?
No. CHORUS Fabric is the free MIT tensor wire protocol (pip install chorus-fabric). ChorusMesh is paid PrismLib cluster orchestration. ChorusControl is the self-hosted AI Ops platform license — offline Ed25519 JWTs issued from insightits.com (portal /dashboard.html#choruscontrol, support /support). Do not interchange the names.
What is the patent status?
Patent pending — not granted. USPTO Provisional Patent Application No. 64/096,156, filed June 22, 2026. Covers tensor multiplication cipher, neural watermark, orthogonal isolation, holographic superposition, and zero-knowledge relay architecture. Read the full technical whitepaper at /whitepapers/chorus-fabric.html.
What are the requirements?
Python 3.10+, PyTorch 2.0+, gRPC 1.64+. Install with pip install chorus-fabric.
Official package links: CHORUS Fabric interactive demo