Actions Orchestration in AI Agents
In the early days of computing, we mostly wrestled with linear, deterministic workflows—programs that did one thing at a time and did it by following explicit instructions down to every semicolon. Then large language models (LLMs) burst onto the stage. Suddenly, it wasn’t enough to feed text prompts into an LLM and hope for the best. We started demanding real “agents,” entities capable of stepping beyond the role of mere text generators by actively choosing their own next steps in code execution.
Smolagents—with their whimsical DoggoLingo-inspired name—represent one such movement toward modular and “agentic” AI. The movement toward orchestrating LLM-driven processes, each specialized for distinct tasks, chained together into code-based ecosystems. In a sense, these “smol” units of agency demonstrate how big the future of AI really is. As John Werner points out, referencing new smolagents research, the impetus is “to implement simplicity and show how components work together” [Werner, Forbes, 2025].
In this essay, I will explore how “actions orchestration” is reshaping AI-driven code execution—why it’s a big deal, how frameworks like smolagents are catalyzing the transition, and what the future might look like as we unlock entire code bases run by, or at least co-piloted by, AI systems. I’ll also examine why Narya, a next-generation AI initiative, is pushing these concepts forward, bridging not just code generation but the entire chain of code execution across many ephemeral AI agents.
The Spectrum of Agency
To understand what “actions orchestration” really means, you first have to parse the levels of agency that define AI autonomy. From the earliest days of LLM usage, we put our large language models into tidy boxes—call an API once, get an answer, and move on. But if we let LLM outputs choose how to proceed within a program, we ascend stepwise along a continuum of agentic capabilities.
According to a recent Hugging Face survey on smolagents, we can think of five overarching agency levels [Roucher, Noyan, Wolf, smolagents, 2024]:
No Impact: The LLM’s output is just text and does not change the program’s flow.
Basic Routing: The LLM can choose which path to take (e.g., “if condition, do X; else, do Y”).
Function Calls: The LLM selects which function to call, deciding how to incorporate the model’s suggestions into a broader code execution.
Iteration & Continuation: The LLM repeatedly decides whether it needs more steps or more tools, effectively controlling loops or re-checking partial outputs.
Multi-Agent Orchestration: Agentic workflows can call and even spawn more agentic workflows.
At that fifth level, we can watch one LLM-based agent instruct another, verifying or refining steps along the way. That’s the “holy grail” scenario for many of us working on advanced automation.
Why Code Matters
You might ask: “Aren’t LLMs just about language? Why shift all the emphasis to code?” The answer is that our most powerful industrial processes run on software. When we want an LLM to do something real—like parse a table, deploy a container, or build a user interface—it has to cross the boundary from text to code.
But how do you get from an LLM’s ephemeral text response to actual executed logic? Historically, developers coerced LLMs to produce code as text, then parsed that text, then compiled or interpreted it. Smolagents, however, propose letting the LLM produce direct code actions—like a Python snippet containing a function call—so that the orchestration environment can execute it in a sandboxed environment. This synergy addresses a subtle challenge: JSON-based or plain text instructions are brittle. You get “string-escaped nightmares,” or you must re-parse code that LLMs themselves can’t keep track of.
As these new patterns show, code is itself the best interface to a computer—so letting the LLM speak in code is more natural and (some argue) more robust. Anthropic’s recent overview concurs: “Writing actions in code is better than JSON because we crafted code languages specifically to be the best possible way to express actions performed by a computer” [Anthropic, Building Effective Agents, 2024].
Simplicity vs. Complexity
There is a tension in building agentic systems: a simpler system is typically more stable, while a more open-ended multi-agent approach can unlock extraordinary capabilities. The question is always whether you need the complexity or if a single pass with a “deterministic workflow” is sufficient.
For many use cases, we can predefine all the steps in code, letting an LLM supply only discrete text. But for more sophisticated scenarios—like responding to a complicated travel request involving passports, times, and distances, or orchestrating changes across multiple code files for a software patch—an LLM that can programmatically choose which function or tool to call next offers far greater coverage and flexibility [Roucher et al., smolagents, 2024].
Narya, which aims to unify and scale up code orchestration, exemplifies how we can harness that multi-agent approach. By empowering ephemeral LLM-driven “workers” to operate in parallel or in sequence, an orchestrator can assign each worker specific tasks: retrieve code from a repository, run tests, interpret logs, fix bugs, redeploy, etc. This is reminiscent of Anthropic’s orchestrator-workers pattern [Anthropic, 2024], but Narya’s vision extends across complex enterprise deployments with minimal human babysitting.
Key Hypotheses: Why Action-Oriented Agents Will Prevail
Cost-Effectiveness: Although multi-step or multi-agent solutions may look expensive at first, every year we see a decline in the computational costs of AI models. Meanwhile, the ability to handle ever more complex tasks creates huge ROI potential.
Enhanced Reliability: Tools like smolagents nudge the LLM into writing code that is testable. The code is not just ephemeral text—it’s an artifact that can be executed, debugged, and monitored. Over time, systematic testing loops (like the evaluator-optimizer workflow) raise the bar on reliability.
Scalability: With well-structured code-based actions, you can spin up ephemeral worker agents, each specialized for certain tasks (graphics, text analysis, data queries), then retire them once done. Think microservices—but for AI.
Human Collaboration: Paul Graham has often emphasized how the best ideas thrive by making iterative, pragmatic improvements. With action-oriented AI, humans can “drop in” at key checkpoints, guiding or gating the process. That synergy dramatically accelerates code pipelines while still having humans in the loop.
Unbounded Creativity: Sam Altman has repeatedly spoken about the compounding power of AI. Once we allow these systems to call themselves—agent orchestrating agent—there is a big leap in emergent behaviors. We might see fully automated code factories, or entire product roadmaps derived, tested, and deployed by AI.
Smolagents, Brainbase, Narya, and the Future
Smolagents aims to “make agents simple” by providing a minimal, code-oriented library for agentic tasks. At the same time, Narya is building advanced orchestration layers that leverage this simplicity to handle large-scale code generation and execution. If smolagents is the Lego brick, Narya is the city that can be built from those bricks.
Within a few years, we may well see emergent “voting” or “multi-agent memory” systems—clusters of specialized models that debate, refine, and produce code artifacts that far outstrip any single model’s performance. A Narya agent could request domain knowledge from a separate agent, parse it into a specialized subroutine, then feed that subroutine back to a master orchestrator. This is reminiscent of the orchestrator-workers approach [Anthropic, 2024], with the added dimension that each agent is ephemeral, stateless, and replaced with a fresh instance once it’s done—a type of micro-service for intelligence.
The ultimate question is whether entire organizations can or should be replaced by these code-driven LLMs. Many experts foresee a near-future in which teams of human engineers partner with large ensembles of these specialized agents. That partnership might produce better code faster, with fewer bugs, and in more creative ways than we have ever seen before.
Brainbase—spearheaded by Founder and CEO Gokhan Egri—delivers enterprise-focused AI solutions that automate and orchestrate entire workflows across different teams.
Bridging not just code generation but also the chain of code execution reveals how AI systems can seamlessly interact, coordinate, and adapt in real-time.
If you want to hear more about Brainbase’s approach to enterprise automation and Gokhan’s insights into AI’s potential, check out our exclusive interview on Masters of Automation.
Beyond AI to the Bigger Picture
When we talk about “code execution” orchestrated by AI, we’re really talking about a future in which everyday tasks—anything from building a website to diagnosing an internal system malfunction—are spun up in ephemeral contexts. Will an LLM’s ephemeral worker ever truly “own” a project as a human might? The power of small iterative steps, so in time, these ephemeral agents could be “trained” by repeated exposure to your domain, forging a kind of collective memory. Exponential improvements in hardware and new training paradigms mean tomorrow’s agents will be a thousand times more capable than today’s.
And so, the future is a synergy of two edges: on one side, the specialized ephemeral agent that tackles tasks in a short, powerful burst; on the other side, an orchestrator that sees the big picture, coordinating tasks among many code-savvy subagents.
Conclusion
Actions orchestration is not a fringe concept. It’s emerging as the central design pattern for building AI applications that actually do things. As we close the first chapter of purely chat-driven AI and open the next on agent-driven automation, the question is not whether we will see code orchestrated by AI, but how soon and how pervasively.
Smolagents, with a playful nod to DoggoLingo, give us a structured scaffolding for multi-step, code-oriented AI. Narya and other new orchestration platforms take that scaffolding and scale it to entire organizations, bridging idea and execution in ways we’re only beginning to fathom. If you believe, as I do, that the real metric for AI success is meaningful code that ships on time and works in production, then you’ll see the pivot from textual generation to orchestrated, code-driven agents as the biggest leap forward yet.
In the words of an old engineering maxim: “We shape our tools, and thereafter our tools shape us.” Let us shape these new agentic workflows with care. For they will, in due course, reshape the world of software—and possibly the world beyond software, too.
References
Graham, Paul. Various Essays on Software and Startups.
Werner, John. “Using Smolagents For Code Automation.” Forbes, January 2, 2025.
