Three frontier labs pivoted to runtime in twelve months. One did not. Here is what dies and what gets built.
It is Wednesday at a French bank. Your agent prototype works on the happy path. Then someone asks what happens when the third tool call fails halfway through a twenty two step KYC review at 2am.
You go look at your LangGraph code. You see a state machine in Python. You do not see retries. You do not see checkpointing. You do not see human approval queues. You see a wall.
You spend a week prototyping on Temporal. Durable execution, deterministic replay, exactly once semantics. It works. You feel smart. Then you remember Temporal will not run your LLM calls inside a workflow because they are non deterministic. You will need to build a wrapper. A sandbox. An observability stack. Credential rotation. Two months of platform work before the agent ships.
While you are scoping the platform work, Mistral ships Workflows. Anthropic ships Managed Agents. OpenAI extends Agents SDK with Agent Builder and ChatKit. Each of them has built the Temporal shaped piece, plus the sandbox, plus the observability, plus the credentials, and they hand it to you behind a small API surface. You did not need a platform team. You needed your model vendor to become a platform.
Three frontier labs, inside roughly the same twelve month window, shipped what is functionally the same product. It is not a coincidence and it is not a feature. It is the moment model labs stopped being model labs.
If you build agents in production, this collapses at least three vendor categories you were evaluating. If you draft platform architecture, your section on durable execution just got shorter. If you allocate capital, the orchestration layer just acquired three new incumbents who already own the model layer.
Before we start! 🦸🏻♀️ If this helps you ship better AI systems: 👏 Clap 50 times (yes, you can!), Medium's algorithm favors this, increasing visibility to others who then discover the article. 🔔 Follow me on Medium, LinkedIn and subscribe to get my latest article.
Workflows is not an agent feature. It is the operational backbone of everything else in Studio.
Most coverage of the April 28 launch missed this. Workflows shipped alongside four other Studio primitives: Agents, Connectors, Datasets, and Judges. The other four are what you see. Workflows is what holds them together when something goes wrong at scale.
Specifically, Workflows is durable orchestration as a managed product. You define a workflow declaratively, the platform handles state, retries, replay, observability, human approval, and exactly once semantics. Mistral exposes it through the Studio API and the Vibe CLI. Underneath, it runs on Temporal. We will get to why in the next section.
Mistral reports the system was already executing millions of workflow executions per day at preview launch. Treat that figure as self reported. What is verifiable is the customer list: ASML, ABANCA, CMA CGM, France Travail, La Banque Postale, Moeve. These are not API consumers paying per token. These are billion euro enterprises across semiconductors, banking, shipping, public employment services, and energy. They buy platform commitments, not credits.
The architecture matters. Workflows runs on a hybrid model: the control plane sits in Mistral's cloud, the data plane runs inside the customer's VPC. Your prompts, tool calls, and intermediate state never leave your environment. The orchestrator coordinates, but it does not see the payloads.
This is the only architecture that works under GDPR, the EU AI Act, and the sovereignty requirements regulated European enterprises are now writing into their AI procurement. No US frontier lab ships this today. That is the wedge Mistral is using to enter accounts that would otherwise default to OpenAI or Anthropic.
OpenAI built their orchestrator from scratch. Anthropic built theirs from scratch. Mistral made the more interesting bet.
Mistral did not build Workflows. Mistral built an LLM specific layer on top of Temporal, the durable execution engine that runs Netflix, Stripe, Salesforce, and roughly half the financial system's back office. The choice is not lazy. It is the most opinionated bet of the three labs.
Temporal's core primitive is the workflow as code. You write what looks like ordinary Python or Go, the engine guarantees that every step either completes, retries, or replays from the last known good state. Crash the worker mid execution, the workflow continues from where it left off when a new worker comes online. This is durable execution, and it is the property every regulated enterprise needs and almost no LangGraph deployment has.
The trade is real. Temporal enforces determinism inside workflow definitions. Side effects (network calls, LLM calls, anything non deterministic) must be wrapped in activities that the engine logs to event history. You cannot just call an LLM inside a workflow. You define the call as an activity, the activity logs its result, and on replay the workflow reads the logged result instead of calling the LLM again. This means your code looks slightly weirder than it would in LangGraph. It also means your agent does not double charge you when a worker dies mid run.
What Mistral added on top is where the work is. Temporal does not natively handle streaming LLM payloads (token by token responses). It does not handle large payload sizes well (hundred kilobyte tool outputs). It does not have multi tenant isolation by default, and its observability is workflow centric, not LLM centric. Mistral built each of these as Workflows specific extensions, kept the Temporal API surface for engineers who already know it, and shipped the result as a managed service.
Whether this is a long term asset or a long term constraint depends on whether the thing you call agent five years from now still looks like a workflow. If yes, Mistral has the head start. If no, the labs that built from scratch can pivot faster.
For all the architectural argument about durable execution, the code you write looks almost boring. That is the point.
The KYC bank from the opening is not a hypothetical. Workflows ships exactly the shape of program you would write if you sat down to express a regulated multi step agent task as code. Roughly fifty lines:
from mistralai.workflows import workflow, activity, Workflow
from mistralai import Mistral
@activity
async def extract_identity(documents: list[bytes]) -> dict:
client = Mistral()
response = await client.agents.complete(
agent_id="kyc-extractor",
inputs={"documents": documents},
)
return response.parsed
@activity(retry_policy={"max_attempts": 5, "backoff": "exponential"})
async def check_sanctions(name: str, dob: str) -> dict:
return await sanctions_api.lookup(name=name, dob=dob)
@activity
async def score_risk(profile: dict) -> float:
client = Mistral()
response = await client.agents.complete(
agent_id="risk-scorer",
inputs=profile,
)
return response.parsed["risk_score"]
@activity
async def create_account(customer_id: str, profile: dict) -> str:
return await core_banking.create(customer_id, profile)
@workflow
class KYCReview(Workflow):
async def run(self, customer_id: str, documents: list[bytes]):
identity = await self.execute(extract_identity, documents)
sanctions = await self.execute(
check_sanctions, identity["name"], identity["dob"]
)
if sanctions["match"]:
return {"status": "rejected", "reason": "sanctions_match"}
risk_score = await self.execute(
score_risk, {"identity": identity, "sanctions": sanctions}
)
if risk_score > 0.7:
decision = await self.wait_for_signal(
"compliance_review", timeout="7d"
)
if decision["outcome"] != "approved":
return {"status": "rejected", "reason": decision["notes"]}
account_id = await self.execute(
create_account, customer_id, identity
)
return {"status": "approved", "account_id": account_id}
Walk what is happening underneath each line.
Durability. The worker running this dies between extract_identity and check_sanctions. A new worker spins up, reads the event history, sees that extract_identity already returned a result, skips it, runs check_sanctions next. You do not pay for the LLM call twice. You did not write the recovery logic. Workflows did.
Retries. The sanctions API is flaky. check_sanctions carries a retry policy: five attempts, exponential backoff. No try except in the workflow code. No retry queue you maintain. The platform reads the policy and applies it.
Human in the loop. When the risk score crosses 0.7, the workflow calls wait_for_signal("compliance_review", timeout="7d") and pauses. It does not occupy a worker. It does not consume memory beyond the serialized state on disk. The compliance officer reviews the case in Studio (or in a custom UI you build on top), clicks approve or reject, the platform sends the signal, the workflow resumes. Median wait might be three hours, p99 might be three days. The code does not care.
Audit. Every activity result is logged with a timestamp. A regulator asking what happened to customer 84319 on March 14 gets a deterministic answer from event history, not a guess from log scraping.
Replay. A bug in score_risk surfaces six months later. You fix it, replay the workflow against the original event history, the corrected code produces the right result without re running any LLM call. This is forensic debugging that frameworks do not ship.
In LangGraph, every one of these properties is eight weeks of platform work. Retries you write. Event history you build (on what database, with what retention, against what schema). Human signals you wire through a queue. Audit you bolt on. Replay you do not get at all, because LangGraph state is not journaled. In Workflows, the same agent is roughly fifty lines and ships on Tuesday.
That is the shape of every regulated agent workload in production for the next decade. Frameworks ship the workflow class. The labs ship everything else.
Agent frameworks are not dying because they are bad. They are dying because the abstraction they sold is now ambient.
LangGraph, CrewAI, AutoGen, Pydantic AI, and the rest shipped the easy 20% of the agent runtime problem. Define a state graph. Define agent personas. Define handoffs. Define tool schemas. The developer experience is excellent, the time to first prototype is measured in hours, and the open source license is permissive.
The hard 80% is everything that comes after the demo. Durable execution that survives worker crashes. Audit trails that satisfy a regulator. Human approval queues that block a workflow until someone clicks. Credential rotation that does not require redeploying the agent. Multi tenant isolation between customers in a SaaS deployment. Observability that lets you ask what did this agent do for user X last Tuesday. Frameworks do not ship any of this. They expect you to bolt it on.
For two years, "bolt it on" was a viable answer because no one was selling the bolt on. Today, three frontier labs are. Workflows, Managed Agents, and Agent Builder ship the hard 80% as a managed service. Not as a feature. As the operational substrate. The frameworks now sit on top of the substrate, not next to it.
The honest counter: frameworks still win three things. Multi LLM portability (Workflows does not run Claude, Managed Agents does not run Mistral). Self hosted deployments where regulation prevents managed services entirely. And prototyping speed for greenfield projects where you want to compare three architectures before committing to any vendor's runtime. None of these are small. They define a real long term niche for frameworks. They just are not the same niche frameworks were sold as.
The new equilibrium looks like this. Framework as IDE on top of lab runtime, the way React sits on top of browser APIs. The framework is where you write the agent. The runtime is where the agent lives. The companies that confuse those two layers will lose budget to companies that buy both.
If you read only one announcement, this looks like Mistral's launch. Read three and you are watching a category form. Read four and you see who got left behind.
April 9, 2026. Anthropic launches Managed Agents in public beta on the Claude Platform. The announcement copy explicitly calls it an agent harness tuned for performance with production infrastructure. Sandboxed code execution. Checkpointing. Credential vaults. Scoped permissions. End to end tracing. Memory stores. Session API. Same product as Workflows in everything except the specific durability backend.
Throughout 2025, OpenAI rolled out the same stack in pieces. The Responses API replaced Chat Completions and Assistants. The Agents SDK shipped open source for managed orchestration with handoffs, guardrails, and tracing. Agent Builder shipped as a hosted visual editor. ChatKit shipped as the deployment surface. Sandbox Agents shipped as the isolated execution environment. By the time the SDK reached its first stable release, OpenAI was operating the same five primitive stack Mistral now ships in Studio: agent loop, durable execution, sandbox, observability, identity.
The vocabulary tells you everything. Anthropic calls it harness. Mistral calls it Workflow. OpenAI calls the loop Runner and the unit Agent. Three different words for one primitive. When three competing labs converge on the same primitive in the same twelve months, you are not watching three product decisions. You are watching a category form.
Two pressures forced this. The technical pressure: anyone who has tried to put an agent into production has discovered that agent is not really a model behavior, it is a runtime behavior. The model contributes maybe twenty percent of what makes an agent work in production. The other eighty percent is state management, sandboxing, retries, audit, credentials, observability, and orchestration. Selling a model without that runtime is selling a steering wheel without a car.
The business pressure: token margins are compressing. Mistral Small 4 prices at 5 to 7x below comparable proprietary models. GPT family pricing has dropped substantially in the last eighteen months. Anthropic's per token margin has tightened similarly. If you are a frontier lab and your tokens are commoditizing, you have two options. Move up the stack into the runtime, or watch your margin go to zero. All three labs picked the same option.
One frontier lab stayed in the old model. Cohere still sells deployment nodes, still prices per GPU rather than per workflow run, still positions itself as model and licensing rather than runtime. The bet there is that sovereign on prem AI is enough of a defensible market without going up the stack. The next two years test that bet. If managed runtimes keep winning the European sovereign accounts Cohere would otherwise serve (Workflows is doing exactly this), per node pricing becomes a fossil.
Token revenue looks like the AI business. It is the loss leader for the AI business.
Frontier model pricing dropped substantially in the last eighteen months. Mistral Small 4 ships at a price point that would have been impossible to predict in early 2024. GPT model pricing has compressed across the family. Anthropic's per token gross margin has tightened under competitive pressure. The trajectory is clear: tokens trend toward commodity infrastructure, the way bandwidth and storage did before them. Selling commodity infrastructure is a 10% gross margin business eventually.
Runtime is a different business entirely. A Workflows contract at a regulated bank is multi year, six figure annual recurring revenue, with switching costs measured in months of platform engineering. A Managed Agents deployment at a Stripe or a Ramp is the same shape. Tokens are switchable in an hour. Runtime contracts last three to five years and grow inside the account because every new agent the customer ships rides on the same substrate.
The asymmetry is brutal. A token customer might generate hundreds to maybe ten thousand dollars of annual revenue through the API. A regulated enterprise on a managed runtime contract generates hundreds of thousands to single digit millions from the same workload, at higher gross margin, multi year duration, and lower marginal acquisition cost because the existing token relationship is what produced the deal in the first place. If you are a frontier lab CFO, you do not run the math twice. You move up the stack.
This is what the customer lists tell you. ASML and La Banque Postale do not buy tokens. They buy platforms. Stripe putting 1,370 engineers on Claude Code is not an API contract. It is a platform deployment with internal integration, security review, and billing terms negotiated at the CIO level. The model gets the press release. The runtime gets the procurement signature.
Three audiences, three concrete shifts. None of them are next quarter problems.
If you build agents in production, the first question on every new project changes. It used to be which framework do I use. It is now which lab am I anchoring to. Frameworks are how you write the agent. The lab's runtime is where the agent lives. Pick the lab first, the framework second. Concrete signal: if your platform team estimates more than three weeks of engineering to ship retries, audit, and human approval, you are reinventing a managed service that already exists. Buy it. Use that team for differentiated work.
If you architect platforms, framework choice is no longer a productivity question. It is a sovereignty question. Workflows runs Mistral. Managed Agents runs Claude. Agent Builder runs OpenAI. Picking one means committing your durable execution layer to one model family for the contract duration. The hybrid pattern becomes standard: managed runtime for the primary model family, framework abstraction for the long tail of fallback and specialized models. Plan for both. Documents that recommend a single runtime will look naive in eighteen months.
If you allocate capital, the orchestration layer just got three new incumbents who already own the model layer. LangChain bet on orchestration as the moat. Temporal bet on durable execution as the moat. Both raised at multi hundred million dollar valuations. Both are now competing with companies whose models they wrap. The portable companies will win the layer the labs cannot ship: sovereign and on prem deployments, multi LLM portability, and the framework ergonomics that no managed runtime currently matches. The companies that compete head to head with managed runtimes on the same axis (durable execution at scale, observability, audit) will be priced out.
Every category forming announcement is also a list of things that are not yet shipped. Read the gaps as carefully as the features.
Workflows runs Mistral models. If your production stack mixes Claude, GPT, and Mistral (most enterprise stacks do), Workflows orchestrates the Mistral portion only. Your Claude calls and GPT calls require Anthropic Managed Agents and OpenAI Agents SDK respectively, or a framework abstraction on top. Mistral has not announced multi LLM support and given the business logic of becoming a runtime company, probably will not.
Pricing is opaque. No public list price for Workflows usage. Enterprise sales only, contract sized to deployment scale. This is normal for early platform products and likely to remain that way for the foreseeable future. Plan for procurement, not for self serve.
Temporal lock in is real. Once you express your durable execution as Workflows, migrating off means rebuilding both the orchestration code and the operational tooling around it. The Temporal abstraction is portable on paper (you could in principle migrate to a self hosted Temporal cluster) but Mistral's LLM specific extensions are not, and most of what makes Workflows valuable lives in those extensions. Treat the lock in as similar to picking a primary database vendor.
The self hosted story is partial. The hybrid control plane plus customer VPC data plane covers most regulated deployments, but it is not fully air gapped. The control plane phones home for orchestration coordination. For genuinely sovereign environments (defense, intelligence, certain national infrastructure), you will need a different architecture and Mistral has not announced one.
Ecosystem maturity is the youngest gap. LangGraph has hundreds of community integrations. Workflows has the Mistral surface, plus what Connectors covers, plus what enterprises build internally. This will close in twelve to eighteen months but today it is real friction. If your agent depends on niche third party tools that have a LangGraph adapter and not a Workflows one, factor in the integration work.
None of these gaps undermine the thesis. They define the addressable market for the thesis: large regulated enterprises whose primary model commitment is Mistral, who can absorb Temporal lock in for the durability win, and whose third party tool surface is small or buildable. That is most of the customer list Mistral published. It is not most of the market yet.
The next time someone asks you which model lab is winning, your answer is wrong. Models are not the layer that decides who wins.
Through 2024 and most of 2025, the question was reasonable. Different labs had genuinely different model capabilities, and benchmark deltas mapped onto business outcomes. That window has closed. Frontier model performance converged across the top labs by mid 2025, and the remaining gap is not large enough to drive procurement decisions at the enterprise level.
What replaced it is the runtime. Mistral with Workflows. Anthropic with Managed Agents. OpenAI with Responses, Agents SDK, and Agent Builder. Each lab is now selling the same product with three different brand names: a managed substrate that holds your agents, your state, your sandbox, your audit, and your credentials, with the model included. The model is what the market sees. The substrate is what gets billed.
This is the pivot from model lab to runtime company, and it is not partial. Mistral's customer list is platform contracts. Anthropic explicitly calls Managed Agents production infrastructure. OpenAI is staffing for enterprise deployment, not consumer scale. The press releases still talk about benchmarks because benchmarks are how the press releases get written. The contracts no longer turn on benchmarks.
Three geographies, same bet, one lab that did not move. US labs will compete on ecosystem depth and integration with the existing US enterprise software stack. Mistral will compete on sovereignty, AI Act compliance, and the European procurement ceiling that will not buy US managed services for tier one workloads. Chinese labs will compete inside the firewall. Cohere will compete on per node deployment economics until that market shrinks. The model layer will continue to commoditize. The runtime layer will not.
The right question for the next decade is not which model lab is winning. It is whose runtime is now the substrate of your company, and how long will it take to migrate off when the time comes.
For most enterprises, the answer to the second part is forever. That is what runtime companies sell. That is why the labs are becoming runtime companies. And that is why Workflows on April 28 was not a feature launch.
It was the announcement.