As you build powerful automations with action.do, a critical question emerges: with services capable of executing atomic actions like charge-card or provision-server, how do you control who—or what—can trigger them? In the world of agentic workflows and Business-as-Code, robust functionality requires equally robust security. Uncontrolled access is not an option.
This is where iam.do comes in. It's the powerful and flexible identity and access management (IAM) layer for your entire .do ecosystem. iam.do allows you to move beyond simple API keys and define fine-grained permissions and policies for every action, workflow, and agent, ensuring your automated business logic runs securely and correctly.
Modern automations are not just simple scripts; they are complex, agentic workflows that orchestrate critical business functions. An agent might need to read from a customer database, process a payment, and then provision a new service. Each step is a powerful action.do call.
Without a granular security model, you face significant risks:
You need a way to enforce the Principle of Least Privilege, granting each user, service, or agent only the exact permissions required to perform its job, and nothing more.
iam.do provides the security fabric that underpins your distributed system of actions and workflows. It's built to answer one fundamental question for every single API call: "Is this principal authorized to perform this action on this resource?"
Think of it as the central security checkpoint for your automations. When a request is made to action.do, iam.do transparently intercepts it to verify the identity and associated policies before the action is ever executed.
iam.do operates on a few simple yet powerful concepts that provide comprehensive control over your system.
A principal is the identity making a request. This isn't just a human user. In an agentic workflow, a principal can be:
This is the specific operation the principal wants to perform. For the .do ecosystem, a primary action is action.do:execute.
A resource is the specific object the action is being performed upon. This gives you incredible granularity. You can define policies that apply to:
A policy is a JSON document that brings these concepts together by explicitly stating what a principal is allowed or denied to do.
For example, here's a policy that allows a specific billing agent to execute the charge-card action but explicitly denies it from executing refund-payment.
{
"Version": "1.0",
"Statement": [
{
"Effect": "Allow",
"Principal": "agent:billing-bot-v2",
"Action": "action.do:execute",
"Resource": "arn:do:::action/charge-card"
},
{
"Effect": "Deny",
"Principal": "agent:billing-bot-v2",
"Action": "action.do:execute",
"Resource": "arn:do:::action/refund-payment"
}
]
}
This fine-grained control ensures that even if the agent's logic is flawed or compromised, it is foundationally incapable of performing unauthorized operations.
The true power of the .do platform is how its services work together.
When you build a workflow by chaining multiple atomic actions, iam.do ensures the executing principal is authorized for every single action in the sequence. This builds upon the transactional integrity of action.do by adding a layer of transactional security. If permission is denied for any step, the workflow fails safely and predictably, preventing partial or unauthorized state changes.
In the age of automation and AI agents, security cannot be an afterthought. By integrating identity and access management at the most fundamental level—the atomic action—iam.do gives you the confidence to build, execute, and automate powerful workflows at scale.
Ready to secure your services with fine-grained control? Explore the documentation and start defining policies for your actions today. With action.do and iam.do, you can build not just powerful automations, but truly robust and secure Business-as-Code.