Scott Hanselman

I’ve just published the next installment in my "Theory of Durable Execution" series. Across frameworks we hear terms like workflows, activities, virtual objects, handlers, and functions. Underneath the terminology, they’re all describing a small number of execution patterns. In this new post, I break durable functions down into three forms: 🔹 Stateless functions for one-shot deterministic logic 🔹 Sessions for long-running, interactive orchestration 🔹 Actors for persistent, message-driven state To get there, I walk through: 🔹 The behavior–state continuum 🔹 How identity, lifetime, communication, and concurrency shape execution semantics 🔹 How frameworks like Temporal, Restate, DBOS, and Resonate map onto these forms This builds on the previous two posts in the series: 🔹 Demystifying Determinism in Durable Execution 🔹 The Durable Function Tree (part 1 and 2) This was the last post in this series, distilling the various frameworks down to a simpler logical model. Full post: The Three Durable Function Forms https://lnkd.in/eJHpY9qC

77

7 Comments

"Graphs make provenance first-class. Instead of burying "where did this come from?" inside a dense vector, a graph records sources, activities, and agents as nodes and edges you can query..." https://lnkd.in/efAdV9dx

26

We launched GitHub Agentic Workflows today. 🚀 What’s been most interesting to me isn’t the announcement itself, but how using them over the past few months has changed the way we think about running a software project. When we first set them up on the project’s own repo, we started with fairly contained use cases — daily reports, issue triage, routine automation. Useful, but not world changing. Over time, though, we started noticing that the real leverage wasn’t in automating discrete tasks. It was in applying continuous pressure to areas of the codebase that are never really “done”: code quality, test coverage, performance, dependency usage. These aren’t things you fix once. They’re ongoing concerns that require judgment and context. We now run over 100 workflows on Agentic Workflows itself. Some regularly propose structural refactors — splitting up large functions, reducing duplication, simplifying logic. Others analyze how we’re using dependencies and suggest more idiomatic patterns. They open PRs, and we review them like anything else. The difference is that improvement stops being event-driven. It doesn’t depend on someone deciding to run a cleanup effort or prioritizing a tech-debt ticket. It just keeps happening in the background, with humans in the loop. Once you start seeing problems this way — not as isolated fixes but as candidates for continuous encoding — it changes how you approach the repo. The surface area of what’s possible expands pretty quickly. I think some form of continuous AI is going to become a normal part of how serious software projects operate. This is our attempt at making that practical. If you want to learn more: Blog: https://lnkd.in/dUzKnWSA Docs: https://lnkd.in/dYTqYxtb Repo: https://lnkd.in/dBccvF9H

1,337

82 Comments

Seeing quite a few discussions lately about Kafka/Iceberg integrations being "zero-copy" or not. I think this is largely missing the point. First, where I agree is that this integration should be "zero-effort" for users. Materializing a Kafka topic into an Iceberg table shouldn't require more than a click of a button. Queries should provide a uniform way for accessing the data in both a topic and the corresponding table. This is the stream/table duality, and it should Just Work™. Now, whether this requires to store the bytes of data once in a Kafka topic, and a second time elsewhere for table access, shouldn't really matter from a user perspective. I'd argue storing the data twice is actually a benefit, and in fact it's a pattern well established: it resembles the design of WAL and table files known from databases for decades. I don't think anyone ever complained about this structure in their RDBMS? Which makes sense, it's an implementation detail, opaque to users. But as it turns out, having log and table data separately is even more advantageous for the deconstructed database that is Kafka and Iceberg: you can have multiple readers of the same log (Kafka topic), materializing views in multiple destinations and systems optimized for specific use cases. Maybe multiple Iceberg tables with different projections (think PII), maybe an Iceberg table and a full-text index in Elasticsearch, maybe an... you catch my drift. Furthermore, the log is replayable, so you can recreate views if needed, or you can implement new use cases you didn't originally have in mind. All in all, I think "zero copy" is mostly a red herring. Sure, it can be an optimization for certain scenarios, but mostly it's a distraction from the immense value you get from combining Kafka and Iceberg when done the right (seamless) way.

127

26 Comments

LLMs are powerful, but they are stateless machines. They don’t carry memory or intent, they work with the context you provide at that moment. The same model can feel brilliant in one scenario and completely off in another. The difference is not the model, but the context and use case we design around it. The technology is already here. The real opportunity lies in how we shape it to solve real problems.

103

11 Comments

Anthropic just cut off xAI from using Claude and this was inevitable. Last week, Anthropic reportedly blocked xAI’s access to Claude after discovering the team was using it via Cursor to speed up internal development. Anthropic’s terms are clear: you can’t use Claude to build or train a competing AI system. xAI crossed that line. Internally, xAI acknowledged the block, framing it as a short-term productivity hit and a push to accelerate their own tooling. This isn’t new behavior. Anthropic has taken similar action before, including restricting OpenAI and limiting Windsurf over competitive concerns. Why this matters: This episode says less about policy violations and more about where power has shifted. Claude, and especially Claude Code, has become critical infrastructure for AI development itself. When even rival frontier labs rely on a competitor’s model to build faster, you know that model is having a moment. But that also guarantees friction. We’re entering a phase where: 🔹 Models are competitors 🔹 Tools are dependencies 🔹 And “coopetition” gets very messy very fast This won’t be the last cutoff. The real battle now isn’t just whose model is best, it’s who controls the tools everyone else needs to build.

133

18 Comments

Retrieval Augmented Generation (RAG) in Microsoft Copilot Studio combines the reasoning capabilities of language models with trusted, organization‑specific knowledge. It enables agents to produce accurate, contextual, and grounded responses based on the enterprise's content rather than relying solely on model memory. We've just added a new article to our Copilot Studio Guidance documentation that covers: - Understand how RAG enhances AI reliability and groundedness. - Describe how Copilot Studio retrieves and synthesizes knowledge. - Identify the supported knowledge sources and their constraints. - Recognize governance, compliance, and AI safety considerations. - Apply RAG concepts when designing agents in enterprise environments. Check it out here: https://lnkd.in/em6iQwXd Thank you to Rémi Dyon for helping draft this content!

465

6 Comments

Agentic Coding Tools Are Forcing Better Documentation Anyone who’s joined an existing product knows the pattern. The "why" is often locked in tribal knowledge. Decisions, tradeoffs, and historical context are missing, outdated, or never written down. Documentation was created once, checked off, and forgotten. Agentic coding tools (Windsurf, Claude Code, etc.) make that impossible to ignore. These tools don’t just generate code. They reason across a codebase using context, constraints, and intent. That makes documentation a first-class input: → design intent → conventions and standards → explicit guardrails In large codebases, consistency won’t come only from reviews anymore. Documentation becomes part of how these tools behave. Bad docs don’t just slow teams down. They create risk — and agentic tools will amplify it. Well-maintained documentation lets both humans and agents move faster, with confidence. #AgenticAI #Documentation

20