@DurableStreams
Account based inUnited States
About this account
- Account based in
- United States
- Connected via
- Web
Account-level information from X, not a live location or the device used for a specific post.
The data primitive for the agent loop.
Joined March 2026
- Tweets44
- Following15
- Followers426
- Likes55
Durable Streams retweeted
This is quite the example for the implementation idea of Durable Stream o have which is a multi turn collaborative document intelligence platform:
Durable Streams based durable transport and session implementations for TanStack AI and the Vercel AI SDK
electric.ax/blog/2026/01/12/…
Introducing Durable Sessions — the key pattern for collaborative AI.
As the world moves to getting things done through agents, the winners are going to be the products that combine AI with collaboration. Building AI apps on a Durable Session pattern is the best way to do that.
The post linked in the 🧵below shows how you can build Durable Sessions into your existing stack, schema and AI SDK using Durable Streams from @ElectricSQL and @TanStack DB.
Durable Streams retweeted
I'm putting my money where my mouth is
2026 is the year of Durable Streams
....now on Rivet Actors
...and written in pure Rust
...with SSDs + S3 tiered storage
Durable Streams retweeted
Introducing Flue 2 — Build dynamic agents that evolve over time.
Flue is a TypeScript framework for building the next generation of agents, powered by the @pidotdev agent harness.
The Flue 1.0 Beta was released last month & has now been downloaded 700,000+ times. And from all of that feedback, we realized something we'd missed.
Agents have a familiar problem: composability.
How do you compose together different agent capabilities in a way that feels expressive AND maintainable, especially as you scale up complexity?
Last week, I teased: “What if React for Agents?” and yes, as you will see, the inspiration here is obvious. But UI devs and agent devs have some things in common, including the same problem that the React team solved almost a decade ago with... Hooks!
There are now things that you can do in Flue 2.0 with hooks that are just fundamentally difficult in other frameworks:
A Flue agent can enforce a multi-step workflow, earn new tools once certain conditions are met, or trade up to a bigger model when the work gets too hard.
Handling metadata and context no longer requires custom framework APIs and configuration. In Flue, you can pass data to a tool the same way you pass arguments to a function.
I'm really excited for you to try Flue 2.0 out yourself. It's a big, bold take on what agents could be capable of in the future.
Read more: flueframework.com/blog/flue-…
![export function MyAssistant() {
const [count, setCount] = usePersistentState('count', 0);
useAgentStart(() => setCount((n) => n + 1));
useModel('moonshot/kimi-k2');
return `You are a helpful assistant. This conversation has ${count} messages.`;
}](/pic/https%3A%2F%2Fpbs%2Etwimg%2Ecom%2Fmedia%2FHOkpOOhbsAAJzn8%2Ejpg%3Fname%3Dsmall%26format%3Dwebp)
ALT export function MyAssistant() { const [count, setCount] = usePersistentState('count', 0); useAgentStart(() => setCount((n) => n + 1)); useModel('moonshot/kimi-k2'); return `You are a helpful assistant. This conversation has ${count} messages.`; }
Durable Streams retweeted
Electric Circuits is our new incremental query engine that allows any Postgres query to be incrementally updated and streamed to your application front end.
It builds on DBSP for IVM and @DurableStreams to resilient transport.
Incredibly scalable, and very, very fast 🔥
This is Electric Circuits: a new primitive that turns any static database query into a live one — fine-grained reactivity, end to end, from Postgres to your app.
Built on DBSP and @DurableStreams
Durable Streams retweeted
Agent sessions are append-only logs, a perfect match for @ElectricSQL's @DurableStreams. Just had to write the agent-agnostic session protocol on top.
Try it yourself — it's open source: github.com/kevin-dp/agent-se…
Durable Streams retweeted
Three weeks ago PGlite crossed 10 million weekly downloads.
Today it just crossed 11 million!
It grew 10% in three weeks 🤯
Durable Streams retweeted
You can use @DurableStreams to achieve the same behaviour without Websockets and Cloudflare lock-in
Durable Streams retweeted
Very easy to achieve this with @DurableStreams sync primitive and open source
Durable Streams retweeted
🚀 New @DurableStreams rust release is out!
Comes with brand-new per-core epoll engine for live-tail SSE and memory improvements
Flat p99 latency, lower memory footprint per subscriber; increased write throughput.
Checkout the number👇
Durable Streams retweeted
I've been writing a @DurableStreams server in Rust to see how fast it can be.
It reaches nearly a million appends per second on a single 4 vCPU box — an order of magnitude faster than current reference server 🧵
Durable Streams retweeted
Did someone say @DurableStreams at kernel speed?
Who needs user space anyway.
Deep-dive on how it works: electric.ax/blog/2026/06/26/…
Durable Streams retweeted
this works very well for things that have conformance tests btw
wrote an @EffectTS_ fork of @DurableStreams by @ElectricSQL on @cloudflare durable objects by pointing the agent at the durable objects & workers docs, the durable streams codebase and conformance tests
"make it pass the conformance tests"
Durable Streams retweeted
Flue from @Cloudflare is now based on our @DurableStreams protocol!
Just Shipped: Flue 1.0 Beta
Flue is the TypeScript framework for building the next generation of agents, designed around an open agent harness with zero LLM lock-in. It’s like Astro, for agents.
Flue 1.0 has been redesigned around three core primitives:
🔁 Workflows — structured automations designed for background work, where your code drives the agent from start to finish.
🧭 Agents (New!) — autonomous, stateful loops where the model drives itself to complete a given task.
📡 Channels (New!) — connect agents to Slack, GitHub, Linear, Discord, Teams, and more. Flue handles the boilerplate for you.
Everything shares the same durable foundation, powered internally by Pi, Vite, and Durable Streams. Deploy anywhere, use any LLM, and recover running agents across restarts and downtime.
We’ve talked to a lot of teams building agents, and keep hearing the same thing: getting to production is hard work. We built Flue to help change that.
Flue 1.0 Beta is available today. Give it a try and let me know what you think!
ALT flue homepage
ALT flue ecosystem
Durable Streams retweeted
oss.chat now supports image generation and understanding. Uses the new Bun.Image to resize generated images on the server. Deployed to @prisma Compute and using @ElectricSQL Durable Streams for a super smooth token streaming experience.
Durable Streams retweeted
Loops you say?
durablestreams.com
Durable Streams retweeted
Your agents don't live in a sandbox, they live in a function and a log.
Split state and compute.
We've built the architecture for the future of agentic software.
Durable Streams retweeted
Every major AI platform has now shipped managed agents. On the same sandbox-based architecture.
That architecture is wrong. Managed agents don't belong in sandboxes. They belong in functions 🧵👇
livetrace.necmttn.com
built on @EffectTS_, ships with @DurableStreams support
github.com/necmttn/livetrace
Just open-sourced Ursula: an HTTP event streams server.
Built on @ElectricSQL's Durable Streams Protocol, Ursula keeps a combo we have not seen elsewhere: { Apache 2.0, quorum-replicated, sub-50ms p99, S3 economics }.
github.com/tonbo-io/ursula
