After Claude Dynamic Workflows, Why Is Progress Still JSON? From multiagent_20261001 to workflow_run.status_ended

As of 12 October 2026: the 9 October beta lets a Managed Agent write a workflow. Progress is not the final sentence. It is workflow_run events. completed means the program finished, not that every thread succeeded.

Dynamic workflows take away “wait for the model to finish, then parse.” The progress contract is still a stream of JSON events. On 9 October 2026 Claude Managed Agents opened dynamic workflows in beta, under the managed-agents-2026-04-01 header. The agent writes a program. The server runs it in the background as a workflow run. What you follow is not the final sentence. It is workflow_run.* on the session event stream.

This piece is written for 12 October 2026, from the release note and the Workflow runs page that were current that day. We already cover the Agents API and JSON Schema and MCP, Skills, Tools, and Subagents. Here the only question is which JSON document counts as the end of a run, and which one must not be treated as success, when hundreds of pieces run apart.

What opened on 9 October

The switch sits on the agent’s multiagent block. With type multiagent_20261001, both subagents and workflows are on by default. For workflows only, set subagents to disabled. Agents you already created go in workflows.predefined_agents. Agents the workflow writes itself are inline agents, and that path is on by default too.

{
  "type": "multiagent_20261001",
  "workflows": { "type": "enabled" }
}

A run has three layers. The outer one is a background workflow run. A session can have several open at once. The middle is phases, with names the model writes, such as “Read the contracts.” The inner layer is agent threads: the program can start many agents at once, pass one result to the next, and repeat inside a phase. A failed agent can be handled by the program, or allowed to end the run. Only the agent starts a run. No event you send ends one. Archiving the session can.

The events travel on the session event stream, and listing session events returns them too. They do not trigger webhooks. The default lifetime is 24 hours. The agent can set a shorter one. Time spent waiting on your client, and time spent paused, still counts. A run that stays paused can end with timeout_error.

created is the phase list

workflow_run.created carries workflow_run_id (a wrun_ id), name, description, and phases. Each phase has an id (a wrph_ id), a name, and a description. When the workflow gives no description, the field is null. phases is always present and can be an empty array. The names are text the model wrote, or a name the server assigned, and they can repeat words from your request. Do not treat them as a stable enum.

{
  "type": "workflow_run.created",
  "id": "sevt_01abc",
  "workflow_run_id": "wrun_01J8XkN5uT3vHpLqRfWdY2",
  "name": "Find change-of-control clauses",
  "description": "Reads each contract and lists those that have the clause.",
  "phases": [
    {
      "id": "wrph_01Kd3a1f3",
      "name": "Read the contracts",
      "description": "Reads each contract for the clause."
    },
    { "id": "wrph_01Kd3b7c9", "name": "Reconcile the findings", "description": null }
  ]
}

Later phase_started and phase_ended events carry workflow_run_phase_id and no phase name. Look the name up by id in created.phases. phase_ended matches its start through phase_started_id. It does not say whether that phase’s work finished. The page says phases run one at a time, in the order of phases, each at most once, and it also says the API does not guarantee that. Handle more than one open phase, a phase that is not in the list, and a listed phase that never starts. Every phase that starts also ends, before status_ended.

completed is not “the work passed”

workflow_run.status_ended is always the last workflow_run.* event for that run, and it includes result. The run is open from created until that event, whether it is running or idle.

resultMeaning
type completedThe program finished. It does not say every piece succeeded. A thread can fail, or fail to be created.
type stoppedThe agent stopped the run, or the session was archived. The event does not say which.
error timeout_errorThe lifetime ran out. 24 hours by default, or the shorter one the agent set.
error program_errorThe workflow code failed, broke a rule, or a thread failed and the program let that end the run.
error thread_limit_errorThe run went over the limit on agents a workflow may start.
error unknown_errorThe server could not continue, or another server-side limit was hit.

An error result looks like {"type":"error","error":{"type":"timeout_error","message":"..."}}. The message is safe to log. Treat an unrecognized result.type as a run that ended some other way. Treat an unrecognized error.type as an error.

workflow_run.error arrives before status_ended, with the same error. It is not the end. A null workflow_run_id means no run was created. Otherwise keep tracking until status_ended. A model, MCP, credential, or billing failure shows up first as session.error on the failing thread and does not end the run by itself. If that makes a thread fail, and the workflow lets the failure end the run, the run ends with program_error.

Threads do not name their phase

Each agent in a run works in its own session thread. The session.thread_created event that announces it carries that run’s workflow_run_id. Other threads set the field to null. No event or field says which phase a thread is in, and agent_name can repeat inside one run. Follow progress by phase events. Tell threads apart by session_thread_id.

For an agent you listed in predefined_agents, the thread’s agent has id and version. For an inline agent the workflow defines, type is inline and those two fields are absent. It uses the session agent’s model. Its tools, MCP servers, and skills are a subset of the session agent’s. The page says it gets all of them, and also says the API does not guarantee that. Permission policies stay with the tools. Threads share the session sandbox, including mounted memory-store files. Each thread has its own conversation history.

You cannot stop one thread by id, and you cannot archive it while its run is open. To stop, ask the agent to stop the run. While runs are open, a custom tool call can arrive while the session stays running. Do not wait for session.status_idle. Answer an agent.tool_use or agent.mcp_tool_use whose evaluated_permission is ask when that event arrives.

Four JSON documents to check first

  1. The agent’s multiagent block. Type multiagent_20261001, and workflows.type is enabled. If you want workflows only, set subagents to disabled explicitly.
  2. One workflow_run.created. phases is present, ids start with wrph_. An empty array is valid. Do not put the names on a validation allowlist.
  3. One status_ended. Read result.type first. After completed, still read each thread’s events before you call the pieces successful.
  4. The phase start and end pair. Match them with phase_started_id. Look the name up in created phases. A missing name is not a broken parse.

Match events with local JSON tools

Before you turn the beta on, open three texts in the browser: the multiagent block, one workflow_run.created, and one workflow_run.status_ended.

  • JSON Validator — whether each event is legal JSON, and whether result uses a type you recognize.
  • JSONPath — $.phases[*].id pulls the phase ids, then match them to workflow_run_phase_id.
  • JSON Diff — compare the phase list on created with the phase events you later received, and look for ids that were not listed.

Nothing leaves the browser. Read the events flat, then let the agent write a workflow. The server will run the program in the background. Your success check should not be only result.type == completed.

FAQ

Is this generally available, and can I skip the beta header?

As of 12 October 2026 it is still beta. The request needs managed-agents-2026-04-01. Set multiagent type to multiagent_20261001 and workflows to enabled.

If result.type is completed, did every piece succeed?

No. completed means the workflow program finished. A thread can fail, or fail to be created. Failed work is in each thread’s own events.

Can I stop when workflow_run.error arrives?

No. It arrives before status_ended and is not the end. A null workflow_run_id means no run was created. Otherwise wait for status_ended.

Why does phase_started omit the phase name?

The name lives only in phases on workflow_run.created. Look it up by workflow_run_phase_id. phase_ended matches the start through phase_started_id.

Can I send an event that stops one thread?

No. While the run is open you cannot stop a thread by id, and you cannot archive it. Ask the agent to stop the whole run. No event you send ends a run. Archiving the session can.

Is this the same JSON as an MCP tools/list?

No. tools/list is tool discovery. This contract is workflow_run events on the session stream. An inline agent’s tools are a subset of the session agent’s tools, not a second tools/list.

Summary

Dynamic workflows turn “hundreds of documents” into a background program. Progress is still JSON events. The 9 October beta turns them on with multiagent_20261001. created lists the phases. status_ended is the end. completed does not mean every thread succeeded. An error event waits for the later end event. Phase names are not on the phase events. Look them up on created.

Flatten multiagent, created, and status_ended locally before you let the agent write a workflow. The program will run in the background. The success check should not shrink to a single completed.