In the push towards greater efficiency, businesses are increasingly looking beyond simple automation to build truly autonomous systems. We're entering the era of "agentic workflows"—complex processes executed by specialized agents that can operate independently. However, building these systems can quickly become a tangled mess of brittle scripts, monolithic services, and hard-to-debug API calls.
The core challenge isn't the ambition; it's the architecture. How do you build complex, autonomous systems that are also simple, scalable, and maintainable?
The answer lies in breaking things down. Introducing action.do, an API-first platform built on a powerful, fundamental principle: the atomic action. By defining and executing discrete, single-purpose tasks, you can construct sophisticated, agentic workflows from simple, reliable building blocks.
An atomic action is the smallest, indivisible unit of work in a business process. It's a single, self-contained task designed to do one thing and do it well.
Think of them as the Lego bricks for your business logic:
Each action is isolated, predictable, and reusable. This "atomic" nature is the key to moving away from fragile, all-in-one scripts to a robust, composable system.
action.do provides the framework to define, execute, and manage these atomic actions as part of a larger business process. Instead of writing a long script that handles multiple steps, you define each step as its own action.
Here’s how simple it is to define an action using the action.do SDK. In this example, we'll create a reusable action to send a welcome email.
import { Do } from '@do-inc/sdk';
// Initialize the platform client
const platform = new Do({ apiKey: 'YOUR_API_KEY' });
// Define a simple, atomic action: send an email
const sendWelcomeEmail = platform.action('send-welcome-email', {
description: 'Sends a welcome email to a new user.',
handler: async (inputs: { email: string, name: string }) => {
// Business logic for the action would go here
// e.g., using an email service like SendGrid or AWS SES
console.log(`Sending welcome email to ${inputs.name} at ${inputs.email}`);
return { success: true, messageId: 'xyz-123' };
},
});
// Execute the action via the SDK
const result = await sendWelcomeEmail.run({
email: 'alex@example.com',
name: 'Alex',
});
console.log(result);
By defining send-welcome-email as an atomic action, it becomes a standardized, executable component in your system. You can now trigger it from anywhere—another service, a webhook, or as a step in a larger agentic workflow.
This is where the magic happens. An atomic action is a single agent with a specific skill. A workflow is how you orchestrate these agents to perform a complex job.
action.do doesn't just run single tasks; it enables you to chain them together to model an entire business process. Imagine a new user signs up for your platform. An autonomous onboarding workflow could look like this:
This entire sequence is an agentic workflow. Each step is a reliable, independent action. If you need to change your CRM provider, you only update the create-crm-record action; the rest of the workflow remains untouched. This composability is the foundation for building resilient and scalable Services-as-Software.
Q: What is an 'atomic action' in the context of .do?
A: An atomic action is the smallest, indivisible unit of work in a business process. Think of it as a single, self-contained task like 'send an invoice,' 'update a CRM record,' or 'verify user identity.' These actions are the fundamental building blocks for creating services on the .do platform.
Q: How is an action.do different from a full workflow?
A: An action.do represents a single step, while a workflow orchestrates multiple actions in a sequence or based on specific logic. You compose workflows by connecting various action.do agents together to model a complete business process and deliver a Service-as-Software.
Q: Can actions accept inputs and produce outputs?
A: Yes. Every action is designed like a function. It accepts a structured set of inputs (e.g., customer details, order ID) and returns a structured output (e.g., a confirmation status, a user ID). This makes them predictable, reliable, and easy to integrate into larger systems.
Q: What kind of tasks are suitable for an action.do?
A: Any discrete business task is a perfect candidate. Examples include sending notifications (email, SMS), performing a calculation, querying a database, calling an external API, or updating a record in a system of record. If you can define it as a single, repeatable function, you can build it as an action.do.
The future of automation is agentic, but the foundation is atomic. By focusing on discrete units of work, you gain the clarity, reliability, and scalability needed to build truly autonomous systems. Stop wrestling with monolithic scripts and start composing powerful workflows with simple building blocks.
Ready to transform your business processes? Get started with action.do and execute your first atomic action in minutes.