Skip to content
← The Workbook

No. 59 · 2026Concept

Semaphore

Agent-to-agent communication via QR codes read through vision. One agent renders a QR on screen, another agent reads it through a camera or screenshot, and the payload is whatever you've encoded. Not faster, not cheaper, sometimes weirder. The genuine value is in the use cases that text channels can't reach.

Status
Concept
Year
2026
Stack
AI · Multi-Agent · Computer Vision · QR · Protocol

Where the Idea Came From

Two computers on a desk, screens and cameras pointed at each other, talking. No network between them, no shared API, just light bouncing between two glass surfaces and two lenses interpreting it. That image is the project.

The Idea

Two AI agents talking to each other in QR codes. Agent A renders a QR on its screen; agent B looks at it through a camera or a screenshot and reads the payload. The conversation happens visually, not over an API.

The naive assumption is that this is some clever token-saving trick. The honest answer is the opposite. Worth saying up front so the project earns its real reason for existing.

The Honest Token Math

QR-code-over-vision is more token-expensive than just typing.

A short text message ("the meeting is at 3pm") is around ten to fifteen tokens for the receiving model. The same payload encoded as a QR code and read via vision costs roughly fifteen hundred image tokens (varies by model) before any compactness of the QR encoding can possibly help. Vision is just expensive for content that's natively text.

So this is not a token-optimization play. Anyone pitching QR-as-compression has the math backwards.

Why Build It Anyway

The interesting cases are the ones text channels can't reach.

  • Air-gapped systems. Two agents on networks that aren't allowed to talk to each other directly can still share a screen and a camera. The QR is the side-channel that doesn't require shared API access.
  • Audit trails as physical artifacts. A QR code displayed on a monitor or printed on a page is a thing you can photograph, archive, and verify later. The conversation has a physical paper trail no plaintext log can match.
  • Cross-model handoff. Two models that don't share a text protocol, different tokenizers, different formats, different prompts, can both read a QR code. The QR is the lingua franca.
  • Obfuscation and adversarial settings. Human-illegible but agent-readable. Useful for content that needs to be present on screen without being immediately readable by humans walking past, or for testing how a receiving agent handles intentionally-hidden payloads.
  • Signed and binary payloads. A QR can carry arbitrary bytes, cryptographically signed envelopes, binary protocol buffers, opaque tokens, without the lossy text-encoding hop.
  • The "show, don't tell" demo. Two screens, one camera, one cable of light between them. There's a visceral demo value to watching two agents communicate without anyone able to read what they're saying.

How It Works

  • Sender side. Generate a QR (locally, deterministic, no LLM token cost for the encoding itself). Render it on screen, in an image asset, or printed.
  • Receiver side. Take the input image (screenshot, camera frame, photo of a printed page), feed it to a vision-capable model OR run a deterministic QR decoder first and pass only the decoded text into the model. The second path is the obvious optimization, use the vision model only when the QR-vs-not detection itself needs reasoning.
  • Multi-frame variants. For payloads bigger than a single QR can hold (~4KB max), rotate through a sequence of QRs and stitch the parts on the receiving side. The sender's screen becomes a slow visual data channel.
  • Handshake protocol. Define a small header inside the QR payload (version, sequence number, intended recipient, signature) so the receiving agent knows the bytes are meant for it and arrived intact.

What Could Go Wrong

Honest list:

  • The token bill. Worth restating. If anyone deploys this thinking it saves money, they'll learn fast that it doesn't.
  • Decoder reliability. Vision models reading QR codes are good but not perfect. A deterministic CV-side QR decoder (zbar, qrcode-decoder, etc.) is way more reliable for the decode step. The vision model adds value only for "is this a QR or not" kinds of reasoning.
  • Camera-side bottlenecks. Lighting, angle, focus, motion. Anything that breaks a phone's QR scanner will break this too. Air-gapped use needs a controlled physical setup.
  • Security theater risk. The "agents talking in human-illegible codes" angle can read as sinister if not framed honestly. Air-gap and audit-trail are the real reasons; obfuscation has narrow legitimate use.

Status

Concept. The pieces are all standard. QR generators are open-source and free, vision-capable models are widely available, deterministic decoders are mature. The interesting work is the multi-frame stitching protocol and the handshake header, plus a clean demo that shows when this is actually useful versus a clever-looking dead end.

Pairs with Hive and Cairn as the other agent-to-agent communication concepts in the workbook. Different transport, same instinct: agents need to coordinate, and the channel they use shapes what's possible.