IQ-Server · one job, done properly
Stream LLM tokens.
Nothing else.
Better than anything else.
IQ is a streaming server built for one job: carrying the tokens of an LLM answer from your application backend to your users’ browsers, in real time.
It delivers 7 times as many events per CPU as general-purpose real-time servers. When a user’s connection drops, IQ picks up exactly where it stopped, and the user never notices.
1CPU
One process, one core
42,000/s
Events per second
0
Events lost on reconnect
What IQ-Server is
Doing one thing is what makes it fast.
IQ is a streaming server specialized in a single task: relaying LLM output from application backends to browsers.
Publish
Your backend sends each chunk of model output to IQ as it arrives, over a plain HTTP request, from any language.
Fan out
IQ fans it out to the browsers watching that answer over Server-Sent Events, the standard the browser already knows. The built-in
EventSourceis the whole client.Hold
While the answer is being generated, IQ keeps it in memory, so any browser that reconnects resumes exactly where it left off, and the user never notices.
Let go
When the answer ends, IQ lets it go. Your backend already has the result. IQ carries it only while it is being written.
Your backend
Any language
Publishes each chunk as the model writes it
IQ-Server
Holds the answer in memory
Only while it is being written
Your users’ browsers
Built-in EventSource
Resume exactly where they left off
Stream replay
The connection will drop. The answer won’t.
Mobile users change networks. Laptops sleep. Corporate proxies cut idle connections. On a ten-second answer, some of your users will lose their connection mid-stream every day.
With IQ, the browser simply reconnects, and IQ replays exactly the tokens it missed, then continues live. No gaps, no repeats, nothing for your frontend or backend to rebuild. The browser’s standard EventSource does it on its own: it reconnects and tells IQ the last event it received.
- Delivered live
- Lost while offline
- Replayed from memory on reconnect
0
Events lost on reconnect
In the benchmark, one browser in ten lost its connection mid-answer. Every one of them came back to every event it had missed: 0 events lost, at every load level, on one CPU and on two.
Why it matters for AI products
What replay saves you.
Experience
The experience users expect, out of the box.
Replay is built into the server: an answer that loses its connection simply continues where it stopped, without you building anything.
Code
No reconnection logic to build.
No buffering tokens in Redis, no “resume from offset” endpoints, no client-side state machines.
Support
Fewer support tickets about a UI that keeps breaking.
A complete contract for every answer.
Replay is only half of it. IQ also guarantees that every browser learns how the answer ended, even one that reconnects too late.
Every event, in order, exactly once.
All browsers watching an answer see the same events in the same order.
A clear ending.
Each browser receives a final signal: the answer finished, or it failed and why.
An honest “it’s over”.
A browser that comes back after the answer ended is told so right away, and loads the final result from your backend, instead of hanging or showing half an answer.
Slow devices never slow down others.
Each browser is served at its own pace. A slow phone never holds back the other viewers, and is never dropped for being slow.
Connections stay alive while the model thinks.
Regular heartbeats keep proxies and load balancers from closing a stream while an agent waits on a tool.
Specialized, not general purpose
Why general-purpose servers can’t do this at IQ speed.
When a browser reconnects mid-answer
IQ-Server
Resumes from the exact event it missed, from memory, at full speed: 42,000 events/s on one CPU.
Mercure, Laravel Reverb, Soketi (default)
Keep nothing. The browser loses everything sent while it was away: 45 to 56 events of a 429-event run in the benchmark, the middle of the answer.
Mercure with history
Can resume, but writes every event to a database file before relaying it. It never passed 780 events per second, and at just 100 concurrent runs its p99 latency was 20 seconds.
General-purpose servers make you choose: speed without replay, or replay without speed.
IQ keeps every running answer in memory, for as long as it is being written and no longer, so replay costs nothing on the hot path: no disk, no database, no broker. That is how it resumes a browser within milliseconds of reconnecting while relaying tens of thousands of events per second.
Performance and scalability.
IQ runs as a single process on one CPU, or as a cluster that uses every CPU of the machine, and scales with them.
42,000/s
Events relayed on one CPU
2.4ms
p99 latency at 300 concurrent runs
76,000/s
Events relayed on two CPUs
35×
What Reverb moved on the same two CPUs
One endpoint for any language
One endpoint. Any language.
If your backend can make an HTTP request, it can stream through IQ. Publishing is a plain HTTP request with one JSON line per event.
- PHP
- Python
- Node.js
- Go
- Ruby
- Java
- .NET
- anything that speaks HTTP
No SDK required in the browser.
Standard Server-Sent Events, read by the browser’s built-in
EventSource.Any front-end protocol.
AG-UI, the Vercel AI SDK, plain text or your own format: IQ relays your events exactly as you send them. It never reads or changes what you send.
Any model, any provider.
IQ sits after the model, so it works with every LLM, hosted or self-hosted.
Simple, secure tokens.
Your backend signs short-lived tokens with a few lines of code, in any language: one to publish, one to watch. A watch token can never be used to publish.
One Docker image.
For
amd64andarm64. No database, no Redis, no disk and no message broker: everything happens in memory.
Your model is fast. Make sure your users see it.
IQ is the streaming layer AI products should have had from the start: built for tokens, fast on a single CPU, resilient to every dropped connection, and ready to host one app or thousands.