Mike Christensen

Staff Distributed Systems Engineer @ablyrealtime

[Mike Christensen @christensencode]

@nicoalbanese10 @vercel @aisdk Congratulations!

[Mike Christensen @christensencode]

Check out the video: https://t.co/kCBho6YPv8

[Mike Christensen @christensencode]

A lot of folks have been asking me about how @ablyrealtime Durable Sessions work with Durable Execution platforms like @temporalio. So I put together a quick video explainer and a demo!

Takeaways👇

[Mike Christensen @christensencode]

- Durable execution lets you build long-running agents which automatically retry on LLM call failures and recover from process crashes
- Durable sessions lets you build clients which automatically recover and resume dropped connections and stay in sync across devices

Essentially, durable sessions provides a durable, unified and live view of all agent activity - even when executed across many Temporal workflow runs.

[Mike Christensen @christensencode]

This approach has completely transformed the way we approach SDK development at Ably. And for our customers, it means we can expect to close feature coverage gaps across our SDKs on an accelerated timeline.

Well worth a read: https://t.co/aReIYndVxN

[Mike Christensen @christensencode]

This is an excellent post from @paddybyers that very concretely demonstrates how spec-driven development (specified in natural language), combined with portable test definitions (which we call the universal test suite), has proved to be an excellent harness for cross-platform code generation. 👇

[Mike Christensen @christensencode]

The alignment of both the specification and test format creates a feedback loop that leads to very good performance for coding agents.

The portability of this format also allows us to generate SDK implementations across multiple target platforms and languages with greatly improved efficiency.

[Mike Christensen @christensencode]

Back from @temporalio Replay 2026 in San Francisco.

The durable execution category is growing like crazy. Look at these graphs that go up and to the right. Why?

Durable agentic loops are becoming the default pattern for production AI. Temporal makes it really easy to build reliable agents which run for hours.

Durable execution is not *just* about writing code that survives crashes, errors and restarts. It's also about developer velocity.

Temporal are building the "operating system" for distributed computing by layering all the primitives you need (queues, streams, durable data structures) on top of workflows.

Agentic apps are also becoming increasingly complex. The session can have concurrent activity: triggered by concurrent interactions from end users, or agents spawning subagents. This execution typically spans multiple workflows (and child workflows).

Durable sessions (https://t.co/bWUsGxBz2V) are the complementary piece on the client side that keeps the user's view of that work coherent - execution across multiple workflows looks like one continuous session to the user, across multiple tabs and devices, consumable over a single resumable, multiplexed stream.

Huge thanks to @temporalio for putting on a great event!

[Mike Christensen @christensencode]

I'm here in San Francisco at @temporalio Replay to dig into building reliable agents with durable execution!

If you're around over the next few days in SF, send me a DM - would be great to meet. Especially if you're building customer-facing AI experiences with durable execution or durable sessions!

[Mike Christensen @christensencode]

@FUCORY @Dayhaysoos What’s stopping you using flue with whatever durable execution platform you want? Temporal, Vercel WDK etc

I prefer when a library/framework is hyper focused on a specific need and can be composed with other solutions for adjacent needs

[Mike Christensen @christensencode]

I'll be in SF next week for @temporalio Replay

Already added some great-looking talks to my schedule:

@samuelcolvin (Pydantic) on durable agents and long-running AI workflows
@cursor_ai 's Jeremy Stribling on building agentic consumer products
@GradientLabsAI's Eliot Miller on real-time voice agents

If you're at Replay or in SF next week and working on customer/consumer-facing AI, send me a DM. Would be great to meet.

[Mike Christensen @christensencode]

@mattpocockuk Vercel Ship cfp still open https://t.co/bw2WShDJO4

[Mike Christensen @christensencode]

Just a few weeks after @karpathy's LLM Wiki post (https://t.co/wjuVZ2TZrb), it seems everyone is building their obsidian "second brain".

Here's what mine looks like:

At a high level: it's an Obsidian vault, where the agent maintains a Wiki/ folder of entities, concepts, source summaries, and syntheses.

I have skills that run every day and automatically ingest data into the wiki: posts on X and LinkedIn, articles and docs I read, GitHub repos and activity, team meetings, sales calls, and Slack action items, etc.

The wiki is a graph that the agent walks as easily as it navigates code. Every Claude session I run has access to it: whether I am writing code, drafting content, working on internal docs, thinking through product strategy.

Before this, I used to rely on hit-or-miss MCP context retrieval, repeated deep-research agent session artefacts and context that used to live in 30 tabs or a massive context folder dump. Now everything is captured once, automatically structured and maintained and always available to my coding agent if needed, queryable on demand.

Every morning, the ingest cycle surfaces what my team worked on, action items from meetings or slack, insights from customer calls, and new learnings from any materials I have read. Knowledge compounds instead of evaporating.

About 40 skills under .claude/skills/. The biggest family is ingest, with two patterns:

One-off (drop something in mid-day, get it indexed):

/obs-ingest-{url|file|x-tweet|li-post|gh-repo|gong-call|fellow-call}

Daily morning digest (fires from /obs-plan-day-open, also runnable solo)

/obs-ingest-{x-bookmarks|x-likes|x-digest|li-likes|li-digest|gh-activity|gong-digest}

After every ingest, a Python script scans new content for external URLs and can recursively ingest linked content if needed.

Some of what I can do with the data:

• Generate new ideas grounded in current projects and interests (/obs-idea-generate)
• Argue against my current thinking using my own vault as evidence (/obs-idea-challenge)
• Find places where I hold contradictory beliefs across notes (/obs-idea-contradict)
• Surface unexpected bridges between unrelated domains (/obs-idea-connect)
• Trace how my view on a topic has evolved across daily notes (/obs-view-trace)
• See which topics I've gone quiet on, by absence of mentions (/obs-view-drift)
• Get a topological view of the vault, clusters and how ideas relate (/obs-view-map)
• Reshape the coming week around what's most alive in the vault (/obs-plan-week-open)

And the wiki itself stays maintained automatically: /obs-wiki-backlinks wires bare mentions of new entities across the vault, /obs-wiki-graduate promotes ideas from daily notes into standalone pages, /obs-wiki-lint surfaces contradictions and stale claims.

Next I want to run the agent in a @vercel Sandbox, with Pi as the agent, a headless Obsidian for sync, and a UI to use these skills from anywhere.

Curious how others are doing this. DM or reply with what your skill set looks like, particularly if you've taken it to the cloud-hosted side. Especially if you've used headless Obsidian!

[Mike Christensen @christensencode]

It was also great to chat to @nicoalbanese10 about some interesting UX challenges builders need to deal with.

Long agent sessions need client-side list virtualization. Thousands of events get flushed from the server and each one triggers a re-render. It would be cool if the client could window through any portion of the session history without agent/server coordination.

And in many apps (especially non-coding agents), you don't even want to surface the whole agent trace. The durable-execution context (every tool call, thought, intermediate LLM response) can be distinct from what you pipe to the client. You want deliberate curation of what reaches the user. This gets more important as agents move beyond internal tooling into customer-facing products.

I think durable execution + durable sessions is a interesting combo to tackle these problems. Going to play around with this stack and seeing how far I can push things!

[Mike Christensen @christensencode]

Loved @vercel's Workflows workshop in London yesterday. Their agent-era stack (AI SDK + Workflow DevKit + Sandbox) is one of the most coherent I've seen for building AI products.

My take: Workflows essentially makes serverless stateful. Serverless used to mean pushing state into an external store and rehydrating on each invocation. Fine for request handlers. Painful for agents, which carry a lot of it: tool history, in-flight work, subagent exchanges.

With Fluid Compute, the time your agent is suspended waiting on I/O doesn't burn cloud credits.

Durable execution is quietly becoming the default primitive for agents.

I love this stack, but there are still a few gotchas:

[Mike Christensen @christensencode]

I've been thinking about this problem with @ablyrealtime's AI Transport.

The idea: session-layer writes are scoped to the step that produced them. On successful step completion, writes remain visible to clients. On failure, writes associated with the failed step can be excluded. We define a total order over step identifiers which defines an unambiguous precedence across step invocations.

The durable session layer does the step-boundary accounting so the agent & UI code doesn't have to.

[Mike Christensen @christensencode]

Loved @vercel's Workflows workshop in London yesterday. Their agent-era stack (AI SDK + Workflow DevKit + Sandbox) is one of the most coherent I've seen for building AI products.

My take: Workflows essentially makes serverless stateful. Serverless used to mean pushing state into an external store and rehydrating on each invocation. Fine for request handlers. Painful for agents, which carry a lot of it: tool history, in-flight work, subagent exchanges.

With Fluid Compute, the time your agent is suspended waiting on I/O doesn't burn cloud credits.

Durable execution is quietly becoming the default primitive for agents.

I love this stack, but there are still a few gotchas:

[Mike Christensen @christensencode]

But one kind of side effect has no rollback primitive: data you've already sent to the client.

Streaming is the obvious case. Half a response lands in the browser, the step fails, the retry produces another attempt. The client now has two partial responses interleaved. There's no way to un-stream tokens.

[Mike Christensen @christensencode]

@jsngr @aaron_epstein @round @Suhail Mighty it was called: https://t.co/KjmMr8iOHT

[Mike Christensen @christensencode]

@jsngr @aaron_epstein @round Didn’t @Suhail build a startup for cloud browsers, essentially browser pixels? I wonder if the timing just wasn’t quite right