// FREE WEBINAR // STREAMING ARCHITECTURES
Task is a value contract: one result, delivered once, at the end. Long-running work is not a value — it is a process. This session is about the architecture you need once you stop pretending otherwise.
// THE_PROBLEM
Task cannot answerThese are not edge cases. They are the ordinary shape of production work that outlives a request, and most teams solve them by bolting polling loops and side-channel progress APIs onto a return type that was never designed to carry the answer.
01 // LIVENESS
A job has been running for twenty minutes. Is it working, or is it dead? Task has three states — pending, completed, faulted — and “alive and progressing” and “hung forever” are both pending. Every timeout you have wrapped around a long call is a confession that you could not tell them apart.
02 // VOLUME
How do you return a large result set from a Task<Response>? Buffer it all and hope, or page manually and rebuild state management by hand. A stream carries results as they are produced and lets the consumer decide how much to take.
03 // RELATIONSHIPS
How do service A and service B hold a long-running relationship without polling? Polling is what you write when you have no way to be told. Subscribe instead, and the ask becomes “are you still there?” rather than “is it done yet?”
// AGENDA
Real code
A 20-minute re-indexing job streaming live state over Server-Sent Events, where a late subscriber’s first element is the current state. A stream can say “here’s where we are”; a Task cannot.
The core
An AI agent that runs a liveness deadline and a separate no-progress deadline over its own token stream — so “nothing arrived, it is dead” and “heartbeats arriving, zero real output” become different states your code can name and act on.
Where it breaks
The honest part. IAsyncEnumerable backpressures the consumer and barely touches the producer — and Channel<T> only tries, weakly. We look at what happens when the producer is an API, a queue, or the physical world and cannot be slowed at all.
// YOU_LEAVE_WITH
A working decision rule for when Task<T> is genuinely the right answer and when it is costing you, plus a concrete read on where IAsyncEnumerable, ChannelReader<T>, and Akka.Streams each belong in a .NET system. This is an architecture talk, not a feature tour — and it assumes no prior Akka.NET experience.
// AUDIENCE
STRONG FIT
Experienced .NET developers and architects who own services with long-running work behind them — imports, exports, reconciliations, agent runs, device fleets, anything a user has ever asked “is this still going?” about.
ALSO USEFUL
Teams evaluating streaming designs, or already using IAsyncEnumerable or Channel<T> and finding the edges. No Akka.NET knowledge is assumed; the framework appears where it earns its place.
NOT A FIT
Brand-new-to-async programmers, or anyone looking for a general Akka.Cluster or persistence course. This one has a specific thesis and stays on it.
// FAQ
Task, IAsyncEnumerable, and Channel<T> — plain .NET. Akka.Streams only enters once the limits of the language-level tools are already visible, which is the honest order to introduce it in.
Sixty minutes, live, free. Bring the job that nobody can tell the status of.