In the world of workflow automation and complex agentic systems, brittleness is the enemy. A multi-step process can fail for countless reasons, and pinpointing the exact point of failure is often a frustrating exercise in log-diving and guesswork. What if you could build your automations from indestructible, single-purpose bricks?
This is the core principle behind action.do. We believe the future of robust automation lies in atomic actions.
Atomic Actions, Executed Flawlessly. With action.do, you can define granular, single-responsibility tasks as powerful API endpoints. It's the simplest way to build robust, scalable, and maintainable agentic workflows, moving your core logic from fragile scripts to reliable Business-as-Code.
Think of an atomic action as the smallest indivisible unit of work in your entire system. It’s a self-contained, single-responsibility task that is transactional by nature: it either completes successfully, or it fails entirely. There are no partial states.
Some classic examples of atomic actions include:
By breaking down a complex process like "Onboard New Customer" into a series of these atomic actions, you gain unprecedented clarity and control. If the workflow fails, you know exactly which building block—which specific action—needs attention.
Instead of burying your business logic deep within monolithic applications or sprawling serverless functions, action.do lets you define it as a clean, executable API endpoint.
Here’s how you would define and execute a single, atomic action to send a welcome email using our SDK:
import { Dō } from '@do-sdk/core';
const dō = new Dō({ apiKey: 'YOUR_API_KEY' });
// Define and execute a single, atomic action
const result = await dō.action.execute({
name: 'send-welcome-email',
input: {
userId: 'user-12345',
template: 'new-user-welcome',
},
});
console.log(result);
// { success: true, transactionId: 'txn_abc_123' }
The beauty is in the simplicity. The action send-welcome-email handles its own logic internally. Your orchestrator—whether it's an AI agent or a workflow engine—doesn't need to know how to send an email; it just needs to request that the action is performed. The result is a clear success or failure, complete with a transaction ID for perfect auditability.
While action.do is focused on executing a single action perfectly, its true power is realized when these actions are composed into larger sequences. This is the foundation of modern workflow automation.
By chaining these atomic actions, you can construct complex, end-to-end processes that are inherently more resilient.
This modular approach is the key to moving from chaotic scripts to a clean, manageable "Business-as-Code" architecture.
An atomic action is a self-contained, single-responsibility task that either completes successfully or fails entirely, without partial states. Think of it as the smallest indivisible unit of work in your workflow, like 'send-email', 'create-user', or 'charge-card'.
While similar, action.do is designed specifically for agentic workflows. It provides built-in orchestration, state management, logging, and security context that serverless functions require you to build and manage yourself. It's a higher-level abstraction for business logic.
Absolutely. While action.do executes a single action, it's designed to be a fundamental building block within a larger workflow.do. You compose complex processes by sequencing these atomic actions to create robust Services-as-Software.
Actions are designed for transactional integrity. If an action fails, it returns a clear error state and can trigger automated retries, notifications, or alternative workflow paths, ensuring your automations are robust and resilient.
Stop building fragile automations. Start composing powerful, resilient workflows with action.do as your foundation. By focusing on single-responsibility, atomic units of work, you can bring clarity, reliability, and scale to your most critical business processes.
Ready to execute your first atomic action? Get started with action.do today!