I’ve been using Claude Code’s dynamic workflows for a while and I think it’s quietly introducing a new paradigm that’s worth naming. The old paradigm, which most of us know from n8n, Zapier, LangGraph, or any custom DAG, treats the LLM as a node inside a workflow. The graph is static. A human designs the edges and the branching conditions. The LLM gets invoked when the graph reaches a node that needs reasoning or generation. This is AI in Workflow . LLM as Nodes. Claude Code is doing something different. The workflow is not a graph the LLM lives inside. The workflow is something the LLM constructs at runtime by choosing tools, spawning subprocesses, and deciding the next step based on the current state of the world. The orchestrator is the model itself. One small but telling example is run_in_background . The old behavior was that the agent would block and wait for the background process to finish. The new behavior is that the agent yields out of its own run loop right after triggering the background job, and the runtime wakes the agent back up once the result is ready. That is essentially coroutine semantics at the agent level. The agent is no longer a function called by a workflow engine. The agent IS the workflow engine, and the runtime around it acts as a scheduler that can suspend and resume it. This is Workflow in AI . The graph is emergent, not declared. Control flow is decided by reasoning, not by edges drawn in a UI. The design question this raises for AI native startups is real. When you build an agent product, do you: Wrap the LLM in a workflow scaffolding (AI in Workflow). Predictable, debuggable, easy to sell to enterprise, but the ceiling is set by whatever the designer of the graph could anticipate. Let the LLM be the orchestrator and treat traditional workflow primitives (queues, schedulers, background jobs, retries) as tools it can call (Workflow in AI). Higher ceiling, harder to constrain, but the system can handle problems the designer never imagined. My intuition is that the second pattern is where the long term value compounds, and Claude Code is the cleanest production example of it today. The first pattern won’t disappear, but it starts to look more and more like glue code that gets absorbed by a higher abstraction layer. Curious how others here are thinking about this. Anyone designing agents with this shift in mind, especially around how you handle long running tasks and parallel subprocesses? submitted by /u/takeurhand
Originally posted by u/takeurhand on r/ClaudeCode
You must log in or # to comment.