From Chore to Code: Building Your First Agentic Workflow with devs.do

In the life of every developer, there are the chores. The repetitive, manual processes and brittle scripts that hold critical business operations together. Think of tasks like new user onboarding, running code quality checks, or generating daily reports. They're essential, but they're also a time-sink and a source of fragility. What if you could treat these operations like any other piece of software—versioned, tested, and deployed as a robust, scalable service?

This is the promise of devs.do.

Welcome to the world of Business-as-Code. With devs.do, you can transform complex business logic into scalable Services-as-Software, all exposed through simple APIs. It's not just another automation tool; it's a fundamental shift in how you build and run your operations.

In this post, we'll walk you through building your very first Agentic Workflow, turning a multi-step chore into a single, powerful API call.

What is an Agentic Workflow?

Before we dive into the code, let's clarify this core concept. An Agentic Workflow is a declarative sequence of tasks executed by specialized, autonomous agents.

Instead of writing complex imperative code that details every single step, error-handling routine, and retry logic, you simply define what needs to be done. You specify the sequence of expert agents (like a git agent or a security agent) and how data should flow between them. The devs.do platform acts as the runtime, intelligently orchestrating the entire process, managing state, and handling failures.

This declarative approach results in workflows that are more resilient, easier to understand, and infinitely more scalable than traditional scripts.

Let's Build: A Code Quality Analysis Service

To see the power of devs.do in action, let's build a practical service. Our goal is to create an API endpoint that accepts a Git repository URL and automatically performs a series of quality checks on it.

On the devs.do platform, these autonomous services are called "Doers." A Doer is a single-purpose service defined entirely as code.

Here’s how you define a code-analyzer Doer using the devs.do TypeScript SDK.

Step 1: Define Your Doer

First, you'll define the service's contract and workflow. This is where you codify your business logic.

import { Doer, Client } from '@do-inc/sdk';

// Configure your client with an API key
const client = new Client({ apiKey: 'YOUR_API_KEY' });

// Define a new service (a "Doer")
const codeAnalysisService: Doer = {
  name: 'code-analyzer.devs.do',
  description: 'Analyzes a git repository for code quality.',
  input: {
    type: 'object',
    properties: {
      repoUrl: { type: 'string', description: 'The URL of the 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:

• name & description: These give your service a unique, human-readable identifier.
• input: This is the API schema for your service. Here, we're specifying that our Doer expects a JSON object with a single string property, repoUrl. This enforces type safety and automatically generates documentation.
• workflow: This is the heart of your agentic service. It's an array of steps, each executed by a specialized agent.
  • agent: 'git.clone': The first agent clones a repository. We use templating ({{input.repoUrl}}) to pass the URL we received in the API call directly to this agent.
  • agent: 'linter.run' and agent: 'security.scan': Subsequent agents run on the output of the previous steps. The platform handles passing the context (like the file path of the cloned repo) between agents.

You've just defined an entire operational workflow without writing a single line of orchestration logic.

Step 2: Deploy to the .do Platform

Now that you've defined your service as code, deploying it is a single function call.

// Deploy your new service to the .do platform
async function deployService() {
  const deployedDoer = await client.create(codeAnalysisService);
  console.log(`Service deployed successfully at: ${deployedDoer.url}`);
}

deployService();

That's it. Running this script sends your Doer definition to the devs.do cloud, which provisions, secures, and deploys it as a live API endpoint. You now have a scalable, reliable service ready to be integrated into your CI/CD pipeline, a Slack bot, or any other application.

The Power of Business-as-Code

By defining your workflow this way, you've unlocked the benefits of Business-as-Code. Your operational process is now a software artifact. It can be:

• Version Controlled: Store your Doer definitions in Git, track changes, and collaborate with your team.
• Tested: Write unit and integration tests for your workflows just like any other code.
• Deployed Continuously: Integrate devs.do deployments into your existing CI/CD pipelines.
• Scalable & Reliable: Let the devs.do runtime handle the scaling, retries, and error handling that would make a custom script brittle and difficult to maintain.

This paradigm moves your business logic out of disconnected scripts and GUIs and into your core codebase, where it belongs.

Ready to Transform Your Operations?

We've only scratched the surface. Imagine codifying user onboarding, data enrichment pipelines, or infrastructure management as simple, declarative workflows.

The devs.do platform is language-agnostic, with a full REST API and official SDKs for TypeScript/JavaScript, Python, and Go. Whatever your stack, you can start turning chores into code today.

Ready to build your first Doer? Visit devs.do to get your API key and start codifying your business.