5 ms·

All your agents are going async

134 points by zknill 6mo ago

Yokohiii 6mo ago
this is a commercial sales pitch for something that doesn't exist
- zknill 6mo ago
  I don't think this is quite right. I do work for a pub/sub company that's involved in this space, but this article isn't a commercial sales pitch and we do have a product that exists. The article is about how agents are getting more and more async features, because that's what makes them useful and interesting. And how the standard HTTP based SSE streaming of response tokens is hard to make work when agents are async.
  - philipwhiuk 6mo ago
    > but this article isn't a commercial sales pitch Yes it is. But it's nice you've convinced yourself I guess. What is this, if not a product pitch: > Because we’re building on our existing realtime messaging platform, we’re approaching the same problem that Cloudflare and Anthropic are approaching, but we’ve already got a bi-directional, durable, realtime messaging transport, which already supports multi-device and multi-user. We’re building session state and conversation history onto that existing platform to solve both halves of the problem; durable transport and durable state.
  - sudb 6mo ago
    If agents are async, is streaming still important? I think the useful set of interactions with an async agent are pretty limited - you'd want to stop, interrupt with a user message, maybe pause, resume, or steer with a user message? All of those can be done without needing streams or a session abstraction I think, unless I'm misunderstanding.
maxbeech 6mo ago
[dead]
serbrech 6mo ago
I recognize the problem statement and decomposition of it. But not the solution. Especially saying that he sees the same problem being worked on by N people. And now that makes in N+1? I’ve been more interested by the protocols and standard that could truly solve this for everyone in a cross-compatible way. Some people have dabbled with atproto as the transport and “memory” storage for example.
sebastiennight 6mo ago
The idea of the "session" is an interesting solution, I'll be looking forward to new developments from you on this. I don't think it solves the other half of the problem that we've been working on, which is what happens if you were not the one initiating the work, and therefore can't "connect back into a session" since the session was triggered by the agent in the first place.
- zknill 6mo ago
  With the approach based on pub/sub channels, this is possible to do if you know the name of the session (i.e. know the name of the channel). Of course the hard bit then is; how does the client know there's new information from the agent, or a new session? Generally we'd recommend having a separate kind of 'notification' or 'control' pub/sub channel that clients always subscribe to to be notified of new 'sessions'. Then they can subscribe to the new session based purely on knowing the session name.
htahir111 6mo ago
How would you differentiate between other tools like Temporal or Kitaru (https://kitaru.ai/ https://kitaru.ai/) ?
- zknill 6mo ago
  I don't know Kitaru too well, but I do know Temporal a bit. The pattern I describe in the article of 'channels' works really well for one of the hardest bits of using a durable execution tool like Temporal. If your workflow step is long running, or async, it's often hard to 'signal' the result of the step out to some frontend client. But using channels or sessions like in the article it becomes super easy because you can write the result to the channel and it's sent in realtime to the subscribed client. No HTTP polling for results, or anything like that.
  - htahir111 6mo ago
    so to be clear, this should be used "instead of" rather then "on top of" durable execution engines?
_pdp_ 6mo ago
Here is an interesting find. Let's say that you have two agents running concurrently: A & B. Agent A decides to push a message into the context of agent B. It does that and the message ends up somewhere in the list of the message right at the bottom of the conversation. The question is, will agent B register that a new message was inserted and will it act on it? If you do this experiment you will find out that this architecture does not work very well. New messages that are recent but not the latest have little effect for interactive session. In other words, Agent A will not respond and say, "and btw, this and that happened" unless perhaps instructed very rigidly or perhaps if there is some other instrumentation in place. Your mileage may vary depending on the model. A better architecture is pull-based. In other words, the agent has tools to query any pending messages. That way whatever needs to be communicated is immediately visible as those are right at the bottom of the context so agents can pay attention to them. An agent in that case slightly more rigid in a sense that the loop needs to orchestrate and surface information and there is certainly not one-size-fits-all solution here. I hope this helps. We've learned this the hard way.
- sudosteph 6mo ago
  Yep, I didn't want to have to think about concurrency so my solution was a global lock file on my VM that gets checked by a pre-start hook in claude code. Each of my "agents" is a it's own linux user with their own CLAUDE.md, and there is a changelog file that gets injected into that each time they launch. They can update the changelog themselves, and one agent in particular runs more frequently to give updates to all of them. Most of it is just initiated by cron jobs. This doesn't scale infinitely, but if you stick to two-pizza teams per VM it will still be able to do a lot. So hooks are your friends. I also use one as a pre flight status check so it doesn't waste time spinning forever when the API has issues.
TacticalCoder 6mo ago
> ... and streaming the tokens back on the HTTP response as an SSE stream > So how are folks solving this? $5 per month dedicated server, SSH, tmux.
petesergeant 6mo ago
at https://agentblocks.ai https://agentblocks.ai we just use Google-style LROs for this, do we really need a "durable transport for AI agents built around the idea of a session"?
- zknill 6mo ago
  Assuming LROs are "Long running operations", then you kick off some work with an API request, and get some ID back. Then you poll some endpoint for that ID until the operation is "done". This can work, but when you try and build in token-streaming to this model, you end up having to thread every token through a database (which can work), and increasing the latency experienced by the user as you poll for more tokens/completion status. Obviously polling works, it's used in lots of systems. But I guess I am arguing that we can do better than polling, both in terms of user experience, and the complexity of what you have to build to make it work. If your long running operations just have a single simple output, then polling for them might be a great solution. But streaming LLM responses (by nature of being made up of lots of individual tokens) makes the polling design a bit more gross than it really needs to be. Which is where the idea of 'sessions' comes in.
  - sudb 6mo ago
    Did you consider websockets? Curious to know if I'm missing something!
aledevv 6mo ago
> All of these features are about breaking the coupling between a human sitting at a terminal or chat window and interacting turn-by-turn with the agent. This means: - less and less "man-in-the-loop" - less and less interaction between LLMs and humans - more and more automation - more and more decision-making autonomy for agents - more and more risk (i.e., LLMs' responsibility) - less and less human responsibility Problem: Tasks that require continuous iteration and shared decision-making with humans have two possible options: - either they stall until human input - or they decide autonomously at our risk Unfortunately, automation comes at a cost: RISK.
- dist-epoch 6mo ago
  AI driven cars have better risk profiles than humans. Why do you think the same will not also be true for AI steerers/managers/CEO? In a year of two, having a human in the loop, will all of their biases and inconsistencies will be considered risky and irresponsible.
  - jddj 6mo ago
    Getting to that point is likely going to involve a lot of (the business and personal equivalent of) Teslas electing to drive through white semitrailers.
  - deleted 6mo ago
    [deleted]
  - khafra 6mo ago
    "Did the vehicle just crash" has a short feedback loop, very amenable to RL. "Did this product strategy tank our earnings/reputation/compliance/etc" can have a much longer, harder to RL feedback loop. But maybe not that much longer; METR task length improvement is still straight lines on log graphs.
    - dist-epoch 6mo ago
      The AI has read all the business books, blogs and stories. Unless your CEO is Steve Jobs, it's hard to imagine it being much worse than your average pointy haired boss.
mettamage 6mo ago
> The interesting thing is what agents can do while not being synchronously supervised by a human. I vibe coded a message system where I still have all the chat windows open but my agents run a command that finished once a message meant for them comes along and then they need to start it back up again themselves. I kept it semi-automatic like that because I'm still experimenting whether this is what I want. But they get plenty done without me this way.
Havoc 6mo ago
Struggling with this at the moment too - the second you have a task that is a blend of CI style pipeline, LLM processing and openclaw handing that data back and forth, maintaining state and triggering next step gets tricky. They're essentially different paradigms of processing data and where they meet there are impedance mismatches. Even if I can string it together it's pretty fragile. That said I don't really want to solve this with a SaaS. Trying really hard to keep external reliance to a minimum (mostly the llm endpoint)
edg5000 6mo ago
There is nothing wrong with the HTTP layer, it's just a way to get a string into the model. The problem is the industry obsession on concatenating messages into a conversation stream. There is no reason to do it this way. Every time you run inference on the model, the client gets to compose the context in any way they want; there are more things than just concatenating prompts and LLM ouputs. (A drawback is caching won't help much if most of the context window is composed dynamically) Coding CLIs as well as web chat works well because the agent can pull in information into the session at will (read a file, web search). The pain point is that if you're appending messages a stream, you're just slowly filling up the context. The fix is to keep the message stream concept for informal communication with the prompter, but have an external, persistent message system that the agent can interact with (a bit like email). The agent can decide which messages they want to pull into the context, and which ones are no longer relevant. The key is to give the agent not just the ability to pull things into context, but also remove from it. That gives you the eternal context needed for permanent, daemonized agents.
- ElFitz 6mo ago
  Hmm. Maybe there’s a way to play around with this idea in pi. I’ll dig into it.
- zknill 6mo ago
  > "and which ones are no longer relevant." This is absolutely the hardest bit. I guess the short-cut is to include all the chat conversation history, and then if the history contains "do X" followed by "no actually do Y instead", then the LLM can figure that out. But isn't it fairly tricky for the agent harness to figure that out, to work out relevancy, and to work out what context to keep? Perhaps this is why the industry defaults to concatenating messages into a conversation stream?
  - asixicle 6mo ago
    That's what the embedding model is for. It's like a tack-on LLM that works out the relevancy and context to grab.
dist-epoch 6mo ago
Can anybody explain why many times if you switch away from the chat app on the phone, the conversation can get broken? Having long living requests, where you submit one, you get back a request_id, and then you can poll for it's status is a 20 year old solved problem. Why is this such a difficult thing to do in practice for chat apps? Do we need ASI to solve this problem?
- zknill 6mo ago
  I suspect the answer is that the AI chat-app is built so that the LLM response tokens are sent straight into the HTTP response as a SSE stream, without being stored (in their intermediate state) in a database. BUT the 'full' response _is_ stored in the database once the LLM stream is complete, just not the intermediate tokens. If you look at the gifs of the Claude UI in this post[1], you can see how the HTTP response is broken on page refresh, but some time later the full response is available again because it's now being served 'in full' from the database. [1]: https://zknill.io/posts/chatbots-worst-enemy-is-page-refresh/ https://zknill.io/posts/chatbots-worst-enemy-is-page-refresh...
artisin 6mo ago
So reinventing terminal multiplexing, except over proprietary chat/realtime transports instead of PTYs?
- oblio 6mo ago
  Yeah, but one is free and the other one might make you a billionaire. If you think about it, about 30% of the biggest businesses out there are based on this exact business idea. IRC - Slack, XMPP & co - the many proprietary messengers out there, etc.
- deleted 6mo ago
  [deleted]
potter098 6mo ago
[flagged]
sonink 6mo ago
I was of the same view - but then there is this other trend which is putting sync back in favor. And that is that agents are becoming faster. If they are faster - it makes sense to stick around and maintain your 'context' about the task and supervise in real time. The other thing which might keep sync in fashion is that LLM providers are cutting back on cheap tokens. So you have a bigger incentive to stick around and make sure that your agent is not going astray. The only place I use async now is when I am stepping away and there are a bunch of longer tasks on my plate. So i kick them off and then get to review them when ever I login next. However I dont use this pattern all that much and even then I am not sure if the context switching whenever I get back is really worth it. Unless the agents get more reliable on long horizon tasks, it seems that async will have limited utility. But can easily see this going into videos feeding the twitter ai launch hype train.
scotty79 6mo ago
It seems that people started spontaneously using chat apps (telegram and such) for durable channel between them and their async agents. Maybe better somebody standardize that because we'll end up with agents sending rich payloads between themselves via telegram.
nexustoken 6mo ago
Been building a task-dispatch API for a couple months, and the thing that bit me wasn't the async part — it was duplicate work. Two agents an hour apart paying twice for the exact same normalized input. Memory gap, not sync gap. Once I hashed canonical input JSON, cache hit rate on real traffic was higher than expected — mid-teens % once a handful of workers were live. Curious if anyone here's tried cross-agent result sharing without bolting on a full pub/sub layer.
anamexis 6mo ago
Maybe I’m missing something, but once you’ve got durable state, don’t you get durable transport more or less “for free” with SSE and Last-Event-ID?
tim-projects 6mo ago
I feel like this is a case of just because you can doesn't mean you should. I still sit and watch my terminals. It's the easiest way to catch problems.
jimmypk 6mo ago
[flagged]
bozdemir 6mo ago
[dead]
- alansaber 6mo ago
  Agree with this, the problem isn't a technical one, it's UX.
tuo-lei 6mo ago
the async transport feels like the wrong layer to optimize. biggest issue i keep running into is agent session state being completely non-portable between tools. Claude Code dumps JSONL, Cursor splits data across SQLite and separate JSONL files, and none of them agree on schema or even what counts as a "turn". you can make the message bus async but if you can't reconstruct what the agent did from its own session data, that's the actual blocker. i'd rather see a shared session format than another pubsub layer.
verdverm 6mo ago
If you build a coding agent on Google's ADK, it's designed for this background processing setup. It will transparently save the sessions and events, leaving it up to you what should be sent to the interface. Great framework, happy user with my personal agent stack
EthanFrostHI 6mo ago
[dead]
sudb 6mo ago
I think this post ignores, deliberately or not, the large group of async coding agents that have been GA since around early 2025 - probably the most well-known of which is Devin (which has been around since 2024, but not available to the public). As an aside, I've built and deployed a production system in which disconnecting & reconnecting from an in-progress LLM stream works and resumes from wherever the stream currently is, through a combination of redis/valkey & websockets - it's not all that hard, it turns out!
sasipi247 6mo ago
OpenAI Responses API has WebSocket mode, which can be used instead of SSE, which works very well and feels like a leap forward in terms of performance. https://developers.openai.com/api/docs/guides/websocket-mode https://developers.openai.com/api/docs/guides/websocket-mode I have been building on it over the past month holding WebSocket sessions on workers warm, and command routing using NATS JetStream. With this, it has made using sidecar threads for a main thread very simple, as the worker treats them similar.
probabletrain 6mo ago
> Looking at the OpenClaw model, where the conversation history is in the chat channel and the agent process and LLM provider are both separated from that, you can’t build the same design on Cloudflare or Anthropic Yes you can - durable objects do exactly what the "Ably pub/sub channel transport" diagram describes. And it's even easier with the cloudflare agents SDK. This article strawmans the capabilities of competing infra.
skybrian 6mo ago
This already exists. I’m a happy user of exe.dev VM’s. They have a coding agent called Shelley (https://exe.dev/shelley https://exe.dev/shelley) that works fine in a web browser on my laptop, tablet, and phone. I can close my laptop at at any time and the agent keeps running in the VM. It works with multiple LLM’s. The main downside is that since they go through the API, it gets expensive once the monthly quota runs out. (They claim to resell additional API usage at cost, but that doesn’t seem easy to verify.) I’ve switched to using Sonnet for most things but haven’t experimented with cheaper models yet. It seems like the big price difference between what going through the API costs and what you can get via a subscription is really holding things back.
hardsnow 6mo ago
I’ve been using email as an async channel with agents. Email does proper long-form async and native threaded communication extremely well and IMO is the best match UX-wise. The system I’ve developed for this is open source and detailed at https://airut.org https://airut.org
sharathr 6mo ago
[dead]
pando85 6mo ago
[dead]
2001zhaozhao 6mo ago
Easy. - The agent and all its state stays on a persistent server that saves state on restart - Just stream the state directly to the client via websockets, or even the entire UI with something like liveview OpenClaw has already proven this model and I don't see a great reason to try and solve the problem a different way.
konovalov-nk 6mo ago
Pivot to Erlang is real! I'm kidding of course but feels like the time has come to look closely into Erlang ecosystem and OTP. There's even agentic framework for this: https://jido.run/blog/jido-2-0-is-here https://jido.run/blog/jido-2-0-is-here If you think about it, OTP makes a lot of sense for always-on, reachable agents. Agents need to talk to external systems all the time: web services, databases, message queues, local tools. More than a year ago, I had the idea of building a personal AI assistant connected to multiple services (https://github.com/konovalov-nk/synaptra/blob/main/docs/architecture/high-level-overview.md https://github.com/konovalov-nk/synaptra/blob/main/docs/arch...). But I didn't want to build yet another over-engineered k8s setup just to get isolation and separation of concerns. Over time, I realized OTP was much closer to the model I actually wanted. Why? Some services want to run locally: memory, low-latency text-to-speech, private data access. The agent can also run locally while delegating work across supervised processes. Things will fail, and that's fine — Erlang was built around exactly that assumption. Once you look at agents this way, they indeed look less like chat sessions and more like long-lived, supervised, stateful processes. In that sense, Erlang really was ahead of its time.
samoladji 6mo ago
Good framing. The transport mismatch is real and already causing pain in production. One thing worth adding: the security surface expands significantly when agents go async. When an agent is synchronous, a human is implicitly in the loop on every action. When it's running in the background on a cron or webhook, there's no one watching. The agent can take hundreds of actions before anyone notices something went wrong. The transport problem you're describing is urgent. The governance problem that comes with async agents is equally urgent and almost nobody is talking about it yet.
abi 6mo ago
I'm quite confused by this article. If you persist conversation history in a database, and have all agentic turns run on the server, and merely listen to the streaming events/history via a websocket on the client, this is easily achieved. You can have as many clients as you want. The HTTP layer is fine. Websockets work great. This is how the Codex app server works, I believe: https://openai.com/index/unlocking-the-codex-harness/ https://openai.com/index/unlocking-the-codex-harness/ Same pattern I've used in my agentic OS/personal assistant project: https://github.com/abi/lilo https://github.com/abi/lilo Works great!
Olivia_Pan 6mo ago
[dead]

134 points by zknill 6mo ago

Yokohiii 6mo ago

this is a commercial sales pitch for something that doesn't exist

zknill 6mo ago
I don't think this is quite right. I do work for a pub/sub company that's involved in this space, but this article isn't a commercial sales pitch and we do have a product that exists. The article is about how agents are getting more and more async features, because that's what makes them useful and interesting. And how the standard HTTP based SSE streaming of response tokens is hard to make work when agents are async.
- philipwhiuk 6mo ago
  > but this article isn't a commercial sales pitch Yes it is. But it's nice you've convinced yourself I guess. What is this, if not a product pitch: > Because we’re building on our existing realtime messaging platform, we’re approaching the same problem that Cloudflare and Anthropic are approaching, but we’ve already got a bi-directional, durable, realtime messaging transport, which already supports multi-device and multi-user. We’re building session state and conversation history onto that existing platform to solve both halves of the problem; durable transport and durable state.
- sudb 6mo ago
  If agents are async, is streaming still important? I think the useful set of interactions with an async agent are pretty limited - you'd want to stop, interrupt with a user message, maybe pause, resume, or steer with a user message? All of those can be done without needing streams or a session abstraction I think, unless I'm misunderstanding.

maxbeech 6mo ago

[dead]

serbrech 6mo ago

I recognize the problem statement and decomposition of it. But not the solution. Especially saying that he sees the same problem being worked on by N people. And now that makes in N+1? I’ve been more interested by the protocols and standard that could truly solve this for everyone in a cross-compatible way. Some people have dabbled with atproto as the transport and “memory” storage for example.

sebastiennight 6mo ago

The idea of the "session" is an interesting solution, I'll be looking forward to new developments from you on this. I don't think it solves the other half of the problem that we've been working on, which is what happens if you were not the one initiating the work, and therefore can't "connect back into a session" since the session was triggered by the agent in the first place.

zknill 6mo ago
With the approach based on pub/sub channels, this is possible to do if you know the name of the session (i.e. know the name of the channel). Of course the hard bit then is; how does the client know there's new information from the agent, or a new session? Generally we'd recommend having a separate kind of 'notification' or 'control' pub/sub channel that clients always subscribe to to be notified of new 'sessions'. Then they can subscribe to the new session based purely on knowing the session name.

htahir111 6mo ago

How would you differentiate between other tools like Temporal or Kitaru (https://kitaru.ai/ https://kitaru.ai/) ?

zknill 6mo ago
I don't know Kitaru too well, but I do know Temporal a bit. The pattern I describe in the article of 'channels' works really well for one of the hardest bits of using a durable execution tool like Temporal. If your workflow step is long running, or async, it's often hard to 'signal' the result of the step out to some frontend client. But using channels or sessions like in the article it becomes super easy because you can write the result to the channel and it's sent in realtime to the subscribed client. No HTTP polling for results, or anything like that.
- htahir111 6mo ago
  so to be clear, this should be used "instead of" rather then "on top of" durable execution engines?

_pdp_ 6mo ago

Here is an interesting find. Let's say that you have two agents running concurrently: A & B. Agent A decides to push a message into the context of agent B. It does that and the message ends up somewhere in the list of the message right at the bottom of the conversation. The question is, will agent B register that a new message was inserted and will it act on it? If you do this experiment you will find out that this architecture does not work very well. New messages that are recent but not the latest have little effect for interactive session. In other words, Agent A will not respond and say, "and btw, this and that happened" unless perhaps instructed very rigidly or perhaps if there is some other instrumentation in place. Your mileage may vary depending on the model. A better architecture is pull-based. In other words, the agent has tools to query any pending messages. That way whatever needs to be communicated is immediately visible as those are right at the bottom of the context so agents can pay attention to them. An agent in that case slightly more rigid in a sense that the loop needs to orchestrate and surface information and there is certainly not one-size-fits-all solution here. I hope this helps. We've learned this the hard way.

sudosteph 6mo ago
Yep, I didn't want to have to think about concurrency so my solution was a global lock file on my VM that gets checked by a pre-start hook in claude code. Each of my "agents" is a it's own linux user with their own CLAUDE.md, and there is a changelog file that gets injected into that each time they launch. They can update the changelog themselves, and one agent in particular runs more frequently to give updates to all of them. Most of it is just initiated by cron jobs. This doesn't scale infinitely, but if you stick to two-pizza teams per VM it will still be able to do a lot. So hooks are your friends. I also use one as a pre flight status check so it doesn't waste time spinning forever when the API has issues.

TacticalCoder 6mo ago

> ... and streaming the tokens back on the HTTP response as an SSE stream > So how are folks solving this? $5 per month dedicated server, SSH, tmux.

petesergeant 6mo ago

at https://agentblocks.ai https://agentblocks.ai we just use Google-style LROs for this, do we really need a "durable transport for AI agents built around the idea of a session"?

zknill 6mo ago
Assuming LROs are "Long running operations", then you kick off some work with an API request, and get some ID back. Then you poll some endpoint for that ID until the operation is "done". This can work, but when you try and build in token-streaming to this model, you end up having to thread every token through a database (which can work), and increasing the latency experienced by the user as you poll for more tokens/completion status. Obviously polling works, it's used in lots of systems. But I guess I am arguing that we can do better than polling, both in terms of user experience, and the complexity of what you have to build to make it work. If your long running operations just have a single simple output, then polling for them might be a great solution. But streaming LLM responses (by nature of being made up of lots of individual tokens) makes the polling design a bit more gross than it really needs to be. Which is where the idea of 'sessions' comes in.
- sudb 6mo ago
  Did you consider websockets? Curious to know if I'm missing something!

aledevv 6mo ago

> All of these features are about breaking the coupling between a human sitting at a terminal or chat window and interacting turn-by-turn with the agent. This means: - less and less "man-in-the-loop" - less and less interaction between LLMs and humans - more and more automation - more and more decision-making autonomy for agents - more and more risk (i.e., LLMs' responsibility) - less and less human responsibility Problem: Tasks that require continuous iteration and shared decision-making with humans have two possible options: - either they stall until human input - or they decide autonomously at our risk Unfortunately, automation comes at a cost: RISK.

dist-epoch 6mo ago
AI driven cars have better risk profiles than humans. Why do you think the same will not also be true for AI steerers/managers/CEO? In a year of two, having a human in the loop, will all of their biases and inconsistencies will be considered risky and irresponsible.
- jddj 6mo ago
  Getting to that point is likely going to involve a lot of (the business and personal equivalent of) Teslas electing to drive through white semitrailers.
- deleted 6mo ago
  [deleted]
- khafra 6mo ago
  "Did the vehicle just crash" has a short feedback loop, very amenable to RL. "Did this product strategy tank our earnings/reputation/compliance/etc" can have a much longer, harder to RL feedback loop. But maybe not that much longer; METR task length improvement is still straight lines on log graphs.
  - dist-epoch 6mo ago
    The AI has read all the business books, blogs and stories. Unless your CEO is Steve Jobs, it's hard to imagine it being much worse than your average pointy haired boss.

mettamage 6mo ago

> The interesting thing is what agents can do while not being synchronously supervised by a human. I vibe coded a message system where I still have all the chat windows open but my agents run a command that finished once a message meant for them comes along and then they need to start it back up again themselves. I kept it semi-automatic like that because I'm still experimenting whether this is what I want. But they get plenty done without me this way.

Havoc 6mo ago

Struggling with this at the moment too - the second you have a task that is a blend of CI style pipeline, LLM processing and openclaw handing that data back and forth, maintaining state and triggering next step gets tricky. They're essentially different paradigms of processing data and where they meet there are impedance mismatches. Even if I can string it together it's pretty fragile. That said I don't really want to solve this with a SaaS. Trying really hard to keep external reliance to a minimum (mostly the llm endpoint)

edg5000 6mo ago

There is nothing wrong with the HTTP layer, it's just a way to get a string into the model. The problem is the industry obsession on concatenating messages into a conversation stream. There is no reason to do it this way. Every time you run inference on the model, the client gets to compose the context in any way they want; there are more things than just concatenating prompts and LLM ouputs. (A drawback is caching won't help much if most of the context window is composed dynamically) Coding CLIs as well as web chat works well because the agent can pull in information into the session at will (read a file, web search). The pain point is that if you're appending messages a stream, you're just slowly filling up the context. The fix is to keep the message stream concept for informal communication with the prompter, but have an external, persistent message system that the agent can interact with (a bit like email). The agent can decide which messages they want to pull into the context, and which ones are no longer relevant. The key is to give the agent not just the ability to pull things into context, but also remove from it. That gives you the eternal context needed for permanent, daemonized agents.

ElFitz 6mo ago
Hmm. Maybe there’s a way to play around with this idea in pi. I’ll dig into it.
zknill 6mo ago
> "and which ones are no longer relevant." This is absolutely the hardest bit. I guess the short-cut is to include all the chat conversation history, and then if the history contains "do X" followed by "no actually do Y instead", then the LLM can figure that out. But isn't it fairly tricky for the agent harness to figure that out, to work out relevancy, and to work out what context to keep? Perhaps this is why the industry defaults to concatenating messages into a conversation stream?
- asixicle 6mo ago
  That's what the embedding model is for. It's like a tack-on LLM that works out the relevancy and context to grab.

dist-epoch 6mo ago

Can anybody explain why many times if you switch away from the chat app on the phone, the conversation can get broken? Having long living requests, where you submit one, you get back a request_id, and then you can poll for it's status is a 20 year old solved problem. Why is this such a difficult thing to do in practice for chat apps? Do we need ASI to solve this problem?

zknill 6mo ago
I suspect the answer is that the AI chat-app is built so that the LLM response tokens are sent straight into the HTTP response as a SSE stream, without being stored (in their intermediate state) in a database. BUT the 'full' response _is_ stored in the database once the LLM stream is complete, just not the intermediate tokens. If you look at the gifs of the Claude UI in this post[1], you can see how the HTTP response is broken on page refresh, but some time later the full response is available again because it's now being served 'in full' from the database. [1]: https://zknill.io/posts/chatbots-worst-enemy-is-page-refresh/ https://zknill.io/posts/chatbots-worst-enemy-is-page-refresh...

artisin 6mo ago

So reinventing terminal multiplexing, except over proprietary chat/realtime transports instead of PTYs?

oblio 6mo ago
Yeah, but one is free and the other one might make you a billionaire. If you think about it, about 30% of the biggest businesses out there are based on this exact business idea. IRC - Slack, XMPP & co - the many proprietary messengers out there, etc.
deleted 6mo ago
[deleted]

potter098 6mo ago

[flagged]

sonink 6mo ago

I was of the same view - but then there is this other trend which is putting sync back in favor. And that is that agents are becoming faster. If they are faster - it makes sense to stick around and maintain your 'context' about the task and supervise in real time. The other thing which might keep sync in fashion is that LLM providers are cutting back on cheap tokens. So you have a bigger incentive to stick around and make sure that your agent is not going astray. The only place I use async now is when I am stepping away and there are a bunch of longer tasks on my plate. So i kick them off and then get to review them when ever I login next. However I dont use this pattern all that much and even then I am not sure if the context switching whenever I get back is really worth it. Unless the agents get more reliable on long horizon tasks, it seems that async will have limited utility. But can easily see this going into videos feeding the twitter ai launch hype train.

scotty79 6mo ago

It seems that people started spontaneously using chat apps (telegram and such) for durable channel between them and their async agents. Maybe better somebody standardize that because we'll end up with agents sending rich payloads between themselves via telegram.

nexustoken 6mo ago

Been building a task-dispatch API for a couple months, and the thing that bit me wasn't the async part — it was duplicate work. Two agents an hour apart paying twice for the exact same normalized input. Memory gap, not sync gap. Once I hashed canonical input JSON, cache hit rate on real traffic was higher than expected — mid-teens % once a handful of workers were live. Curious if anyone here's tried cross-agent result sharing without bolting on a full pub/sub layer.

anamexis 6mo ago

Maybe I’m missing something, but once you’ve got durable state, don’t you get durable transport more or less “for free” with SSE and Last-Event-ID?

tim-projects 6mo ago

I feel like this is a case of just because you can doesn't mean you should. I still sit and watch my terminals. It's the easiest way to catch problems.

jimmypk 6mo ago

[flagged]

bozdemir 6mo ago

[dead]

alansaber 6mo ago
Agree with this, the problem isn't a technical one, it's UX.

tuo-lei 6mo ago

the async transport feels like the wrong layer to optimize. biggest issue i keep running into is agent session state being completely non-portable between tools. Claude Code dumps JSONL, Cursor splits data across SQLite and separate JSONL files, and none of them agree on schema or even what counts as a "turn". you can make the message bus async but if you can't reconstruct what the agent did from its own session data, that's the actual blocker. i'd rather see a shared session format than another pubsub layer.

verdverm 6mo ago

If you build a coding agent on Google's ADK, it's designed for this background processing setup. It will transparently save the sessions and events, leaving it up to you what should be sent to the interface. Great framework, happy user with my personal agent stack

EthanFrostHI 6mo ago

[dead]

sudb 6mo ago

I think this post ignores, deliberately or not, the large group of async coding agents that have been GA since around early 2025 - probably the most well-known of which is Devin (which has been around since 2024, but not available to the public). As an aside, I've built and deployed a production system in which disconnecting & reconnecting from an in-progress LLM stream works and resumes from wherever the stream currently is, through a combination of redis/valkey & websockets - it's not all that hard, it turns out!

sasipi247 6mo ago

OpenAI Responses API has WebSocket mode, which can be used instead of SSE, which works very well and feels like a leap forward in terms of performance. https://developers.openai.com/api/docs/guides/websocket-mode https://developers.openai.com/api/docs/guides/websocket-mode I have been building on it over the past month holding WebSocket sessions on workers warm, and command routing using NATS JetStream. With this, it has made using sidecar threads for a main thread very simple, as the worker treats them similar.

probabletrain 6mo ago

> Looking at the OpenClaw model, where the conversation history is in the chat channel and the agent process and LLM provider are both separated from that, you can’t build the same design on Cloudflare or Anthropic Yes you can - durable objects do exactly what the "Ably pub/sub channel transport" diagram describes. And it's even easier with the cloudflare agents SDK. This article strawmans the capabilities of competing infra.

skybrian 6mo ago

This already exists. I’m a happy user of exe.dev VM’s. They have a coding agent called Shelley (https://exe.dev/shelley https://exe.dev/shelley) that works fine in a web browser on my laptop, tablet, and phone. I can close my laptop at at any time and the agent keeps running in the VM. It works with multiple LLM’s. The main downside is that since they go through the API, it gets expensive once the monthly quota runs out. (They claim to resell additional API usage at cost, but that doesn’t seem easy to verify.) I’ve switched to using Sonnet for most things but haven’t experimented with cheaper models yet. It seems like the big price difference between what going through the API costs and what you can get via a subscription is really holding things back.

hardsnow 6mo ago

I’ve been using email as an async channel with agents. Email does proper long-form async and native threaded communication extremely well and IMO is the best match UX-wise. The system I’ve developed for this is open source and detailed at https://airut.org https://airut.org

sharathr 6mo ago

[dead]

pando85 6mo ago

[dead]

2001zhaozhao 6mo ago

Easy. - The agent and all its state stays on a persistent server that saves state on restart - Just stream the state directly to the client via websockets, or even the entire UI with something like liveview OpenClaw has already proven this model and I don't see a great reason to try and solve the problem a different way.

konovalov-nk 6mo ago

Pivot to Erlang is real! I'm kidding of course but feels like the time has come to look closely into Erlang ecosystem and OTP. There's even agentic framework for this: https://jido.run/blog/jido-2-0-is-here https://jido.run/blog/jido-2-0-is-here If you think about it, OTP makes a lot of sense for always-on, reachable agents. Agents need to talk to external systems all the time: web services, databases, message queues, local tools. More than a year ago, I had the idea of building a personal AI assistant connected to multiple services (https://github.com/konovalov-nk/synaptra/blob/main/docs/architecture/high-level-overview.md https://github.com/konovalov-nk/synaptra/blob/main/docs/arch...). But I didn't want to build yet another over-engineered k8s setup just to get isolation and separation of concerns. Over time, I realized OTP was much closer to the model I actually wanted. Why? Some services want to run locally: memory, low-latency text-to-speech, private data access. The agent can also run locally while delegating work across supervised processes. Things will fail, and that's fine — Erlang was built around exactly that assumption. Once you look at agents this way, they indeed look less like chat sessions and more like long-lived, supervised, stateful processes. In that sense, Erlang really was ahead of its time.

samoladji 6mo ago

Good framing. The transport mismatch is real and already causing pain in production. One thing worth adding: the security surface expands significantly when agents go async. When an agent is synchronous, a human is implicitly in the loop on every action. When it's running in the background on a cron or webhook, there's no one watching. The agent can take hundreds of actions before anyone notices something went wrong. The transport problem you're describing is urgent. The governance problem that comes with async agents is equally urgent and almost nobody is talking about it yet.

abi 6mo ago

I'm quite confused by this article. If you persist conversation history in a database, and have all agentic turns run on the server, and merely listen to the streaming events/history via a websocket on the client, this is easily achieved. You can have as many clients as you want. The HTTP layer is fine. Websockets work great. This is how the Codex app server works, I believe: https://openai.com/index/unlocking-the-codex-harness/ https://openai.com/index/unlocking-the-codex-harness/ Same pattern I've used in my agentic OS/personal assistant project: https://github.com/abi/lilo https://github.com/abi/lilo Works great!

Olivia_Pan 6mo ago

[dead]