The Anatomy of a '.do' Agent: Building Blocks for Your Workflows

In the world of software development, complexity is the enemy. We strive to build systems that are modular, scalable, and easy to maintain. Yet, when it comes to automating business operations, we often fall back on brittle scripts and tangled processes. What if we could apply the same principles of modern software engineering to our workflows?

Enter Business-as-Code. At devs.do, we're pioneering this paradigm, allowing you to transform complex business logic into scalable, version-controlled Services-as-Software. The fundamental unit that makes this all possible is the .do Agent.

This post will dissect the anatomy of a .do agent, showing you how these powerful, single-purpose building blocks are the key to unlocking streamlined and robust agentic workflows.

First, What is an Agentic Workflow?

Before we dive into the agent itself, let's quickly recap what we mean by an Agentic Workflow.

Think of it as a declarative to-do list for a team of specialized AI agents. Instead of writing complex imperative code that details how to perform every single step, you simply define what needs to be done by specifying a sequence of agents and the data to pass between them.

An Agentic Workflow:

1. Defines a sequence of specialized agents.
2. Orchestrates data flow between each agent.
3. Executes tasks autonomously, with the platform handling errors, retries, and scaling.

This approach moves you from writing code to composing systems, which is where .do agents shine.

Deconstructing the .do Agent

So, what exactly is a .do agent?

A .do agent is a single-purpose, autonomous, and platform-managed service that executes one specific task exceptionally well.

Imagine a well-organized workshop. You don't have one giant, clunky machine that does everything poorly. Instead, you have a set of specialized tools: a drill, a saw, a welder. Each one is designed for a specific job.

.do agents are your digital tools. They are the "verbs" in your workflow sentence, the individual functions in your larger application. An agent might clone a git repository, run a security scan, send a Slack message, or query a database.

Key Characteristics of an Agent

• Single-Purpose & Focused: Each agent like git.clone or linter.run is an expert in its domain. This focus makes them highly reliable and reusable across countless different workflows.
• Standardized Interface: Every agent has a clearly defined input schema and a predictable output. This standardization is what makes them "pluggable." The devs.do platform knows exactly how to pass data from a git.clone agent to a security.scan agent without you writing any glue code.
• Fully Managed: You don't need to worry about hosting, scaling, or maintaining the agent's underlying infrastructure. The .do platform handles all of it. You simply call the agent, and it performs its task.

Putting Agents to Work: A Workflow in Action

Theory is great, but code makes it real. Let's look at the workflow definition inside a "Doer" (a complete Service-as-Software on devs.do). This example defines a service that analyzes a git repository.

// Define the agentic workflow
workflow: [
  { agent: 'git.clone', params: { url: '{{input.repoUrl}}' } },
  { agent: 'linter.run', params: { path: './cloned-repo' } },
  { agent: 'security.scan', params: { path: './cloned-repo' } },
],

Let's break this down step-by-step:

1. { agent: 'git.clone', params: { url: '{{input.repoUrl}}' } }

   • agent: 'git.clone': This is the first agent in our sequence. We're telling the platform to invoke the highly-specialized git.clone agent.
   • params: { url: '{{input.repoUrl}}' }: We pass the required parameters. Here, the url for the agent is dynamically populated from the main input of our service ({{input.repoUrl}}).

2. { agent: 'linter.run', ... }

   • Once the git.clone agent successfully completes its task, the workflow automatically proceeds to the next step.
   • The linter.run agent is invoked. The platform implicitly knows the context—the path to the code cloned in the previous step—and makes it available to this agent. You don't have to manage state or temporary file systems.

3. { agent: 'security.scan', ... }

   • Finally, the security.scan agent runs on the same repository path, completing the analysis.

In just three declarative lines, you've orchestrated a complex process that would have otherwise required scripting API calls, handling authentication, managing a file system, and chaining processes together manually.

The Power of the Agentic Model

Building with .do agents isn't just a different syntax; it's a fundamentally better way to build operational logic.

• Composability: You can mix and match from a vast library of pre-built agents to compose new and powerful workflows in minutes, not days.
• Resilience: Since each agent is an independent, managed microservice, an issue in one part of your workflow doesn't need to bring the entire system down. The platform's orchestrator can handle errors and retries gracefully.
• Scalability: Need to run 10,000 code analyses at once? The platform scales the underlying agents to meet the demand without you configuring a single server.
• Focus: Stop writing boilerplate. By leveraging agents, you can focus on the high-level business logic that delivers value, codifying your operations and turning them into scalable assets.

Conclusion: Start Building with Better Blocks

The .do agent is more than just a function call. It's a managed, resilient, and reusable building block for codifying your entire business. By chaining these agents together into Agentic Workflows, you can move from writing brittle automation scripts to engineering true Services-as-Software.

It's time to transform your operations into code.

Ready to start composing? Explore the devs.do platform and build your first agentic workflow today.