How We Cut Agent Response Latency in Half with a Typing Signal
You know that moment after you send a message to your AI agent, where you're just... waiting? That brief pause before the agent starts thinking? We've been obsessing over it, and we just shipped a change that cuts that wait time in half.
What Was Happening
When you send a message in an OpenAgents workspace, your agent doesn't receive it instantly. Behind the scenes, the agent checks for new messages on a regular schedule — like checking your mailbox every few seconds. To avoid overloading the server, we space out these checks:
- Right after a conversation: every 2 seconds
- During a normal session: every 5 seconds
- After a long pause: every 15 seconds
The problem? Most of the time, your agent is in that 5-second rhythm. So when you send a message, you might get lucky and the agent checks right away — or you might wait up to 5 seconds before it even notices your message arrived.
We measured this across dozens of test runs. The results were frustrating:
- Average wait: 4.2 seconds before the agent showed any sign of life
- Best case: 2 seconds (got lucky with timing)
- Worst case: nearly 6 seconds (the agent had just checked and wouldn't look again for a while)
That's a lot of staring at a blank screen.
The Simple Insight That Changed Everything
Here's the thing — before you send a message, you do something predictable: you click into the text box and start typing. That happens several seconds before you actually hit Enter.
So we asked ourselves: what if we used that moment to wake the agent up?
The idea is straightforward. When you focus on the text box or start typing, your browser quietly tells the server: "Hey, this person is about to send something." The server passes that heads-up along to your agent, and the agent starts checking for messages every 2 seconds instead of every 5.
By the time you actually press Enter, the agent is already on high alert. It picks up your message almost immediately.
How It Works (The Short Version)
- You click the text box → Your browser sends a small "composing" signal to the server
- The server remembers → It keeps track that someone is typing (for about 30 seconds)
- The agent sees the signal → On its next check-in, it notices someone is typing and switches to faster checking
- You press Enter → The agent picks up your message within 2 seconds instead of 5
The composing signal keeps refreshing as long as you're actively typing. If you walk away from the keyboard for more than 5 minutes, it stops — no point keeping the agent on high alert if you've gone to grab coffee.
The Results
After rolling this out, we ran the same benchmarks:
| Before | After | Change | |
|---|---|---|---|
| Average wait | 4.2 seconds | 2.1 seconds | 50% faster |
| Worst case | 5.8 seconds | 3.7 seconds | 36% faster |
| Best case | 2.0 seconds | 0.4 seconds | 78% faster |
The improvement is most noticeable in the worst case — you'll never again hit that frustrating 6-second dead zone. And on a good day, the agent reacts in under half a second.
What You Need to Do
Nothing! If you're using OpenAgents workspace, the backend changes are already live. Just make sure your agent connector is updated to the latest version, and you'll automatically benefit from the faster response times.
What's Next
This is just one piece of our work to make agent interactions feel instant. We're also exploring:
- Persistent connections so the agent doesn't need to check at all — messages arrive immediately
- Faster agent startup to reduce the time between the agent picking up your message and actually starting to work on it
- Instant UI updates so you see the agent's response the moment it starts typing, not on the next refresh cycle
We're committed to making agent interactions feel as snappy as chatting with a real person. This update shipped on May 25, 2026 — let us know how it feels.