Product launches are a symphony of controlled chaos. They involve dozens of tasks, multiple teams, and tight deadlines. From updating the website to notifying customers and alerting the support team, every step must be executed flawlessly. What if we could automate the entire orchestration? What if an AI agent could serve as the conductor?
That was the question we asked ourselves. We decided to run an experiment: Could we use our own agent.do platform, built on the foundation of atomic actions, to manage the launch of a new feature?
This is the story of that experiment—a case study in building a truly agentic workflow for a mission-critical business process.
A typical product launch checklist is a project manager's nightmare and a testament to complexity. Ours included tasks like:
Traditionally, this requires a "launch master" to manually trigger, check, and confirm each step. It's time-consuming, prone to human error, and stressful. We hypothesized that we could model this entire process as code and hand the reins to an agent.
The core principle behind the .do ecosystem is that you can't build robust automation on a shaky foundation. Before an agent can act, it needs a library of reliable tools. This is where action.do comes in.
An atomic action is the smallest, indivisible unit of work in a system. Think of it not as a complex process, but as a single, focused task with clear inputs and outputs. It's designed to do one thing perfectly.
For our launch, we broke down our checklist into a series of atomic actions:
Each action is a manageable, reusable, and observable component. This is the foundation of automation. Instead of a monolithic script, we have a set of simple, powerful building blocks.
Here's what defining a simple send-email action looks like with action.do:
import { Action } from '@do-co/core';
// Define the input for our action
interface SendEmailInput {
to: string;
subject: string;
body: string;
}
// Define the output of our action
interface SendEmailOutput {
messageId: string;
status: 'sent' | 'failed';
}
// Create the action as a service
const sendEmail = new Action<SendEmailInput, SendEmailOutput>({
name: 'send-email',
description: 'Sends a transactional email.',
handler: async (input) => {
// Integration with an email provider (e.g., SendGrid, SES)
// would happen here. For this example, we'll simulate it.
console.log(`Sending email to ${input.to}...`);
const messageId = `msg_${Date.now()}`;
return {
messageId,
status: 'sent',
};
},
});
// This action can now be executed within any workflow or agent.
By wrapping our core business logic in this structure, we gain observability, standardized error handling, and the ability to plug this action into any workflow engine.
With our library of atomic actions defined, it was time to build our conductor. We used agent.do to define the launch sequence.
The agent's instructions looked conceptually like this:
The agent initiated the launch precisely on schedule. We watched the Slack channel as notifications popped up in real-time, confirming each step's completion. The email went out, the website updated, and the support ticket was created—all without a single manual click.
The experiment was a resounding success.
Our experiment confirmed our hypothesis: an AI agent, when built on a solid foundation of atomic actions, can absolutely manage a complex business process like a product launch.
The power of this model isn't about replacing humans. It's about elevating them. By encapsulating routine task execution into reliable, automated components, we free up human creativity and strategic thinking. The future of business automation is not a single, all-knowing AI; it's a collaborative ecosystem where humans define the goals and agents, powered by atomic actions, handle the meticulous work of getting there.
What is an 'atomic action' in the context of .do?
An atomic action is the smallest, indivisible unit of work in an agentic workflow. It's a self-contained function (like sending an email or updating a CRM record) with clear inputs and outputs, designed to be reliable, reusable, and observable.
How does action.do differ from a simple function call?
While an action.do wraps a function, it adds a structured layer of observability, error handling, retries, and standardization. This transforms a simple function into a managed, enterprise-grade component for reliable automation.
Can I combine multiple actions?
Absolutely. The core purpose of atomic actions is to serve as building blocks. They are designed to be orchestrated by higher-level services like workflow.do or agent.do to create complex, multi-step business processes.
What are some common examples of an action.do?
Common actions include 'send-email', 'create-support-ticket', 'update-database-record', 'query-api', 'post-to-slack', or 'transcribe-audio'. Each action is focused on performing one specific task perfectly.