Slack Approval Buttons for AI Agent Actions: Decide Before Any Write
Route an AI agent's proposed action to a Slack approval with the request, evidence and expiry, so a person decides before any write happens.

To route an agent's proposed action to Slack for approval, the agent posts a structured request to a dedicated channel or direct message. The request states the exact action, the target system, the evidence behind it and an expiry time, and the write runs only after a named person presses an approve button. A rejected or expired request leaves the business system untouched, and the agent starts over only with a new proposal.
This article explains how to build that flow, what the request card must contain, and where the approval gate belongs in the chain from agent to system.
Key takeaways
- The approval gate sits between the agent's proposal and the write, so the agent never holds the final step alone.
- Each request carries the exact payload, the evidence, the risk level, an expiry time and a stored identifier that the buttons refer to.
- Approve executes the stored proposal. It never asks the agent to regenerate the action after a person has read it.
- Authority to approve is checked on your side, not assumed from channel membership.
- Expired requests fail closed, and a rejection reason goes back to the agent as context for the next proposal.
Why the approval belongs before the write, not after
Many teams first connect an agent to a tool, then try to add review later. By that point the agent already has write access, and every review becomes a cleanup exercise. Placing the approval before the write changes the question a person answers. Instead of checking whether a change was made correctly, the approver decides whether this specific change should happen at all.
The Slack message is only the delivery surface. The real control is a request record stored in your own system, with a state such as proposed, approved, rejected, expired or executed. Buttons in Slack change that state. The write happens only when the state moves to approved and the executing service confirms the stored payload still matches what the approver saw.
This distinction matters because chat buttons are easy to click quickly. A calm, well-specified request is what turns a click into a decision.
What the request card must contain
A request card should answer the questions an approver would ask at a desk. Keep it short enough to read in a few seconds, but complete enough that nobody has to open three other tools to understand it.
- The action in plain language, such as "Create a draft purchase order for the cleaning supplier, 12 units of item 4471."
- The target system and the object affected, so the approver knows exactly where the change lands.
- The full payload, either inline or behind a link that opens a read-only view of the stored proposal.
- The evidence: the source messages, documents or records the agent relied on, linked rather than pasted in full.
- A short statement of what the agent is not sure about, which often prevents the most expensive mistakes.
- The risk level and the reason for it, using categories your team has agreed on in advance.
- The expiry time, the approver group allowed to decide, and the request identifier.
The evidence section deserves care. If the agent summarized an inbound email from a vendor, the vendor's text may contain instructions aimed at the model. The OWASP guidance on prompt injection prevention describes why untrusted content should be treated as data to show, not as instructions to follow. In the card, quote the source and label it as external text, so the approver reads it as material to judge.
Step-by-step: route a proposed action to Slack
The following sequence works for most business agents. It assumes the agent can propose actions but cannot execute write operations directly.
- Step 1: Define the action classes that always need approval. Start with anything that creates a financial commitment, changes a customer record, sends a message to an outside party or deletes data.
- Step 2: Make the agent emit a proposal object with fixed fields, rather than free text. Fixed fields make the card predictable and make the stored payload testable.
- Step 3: Store the proposal in your own system with a unique request identifier, the state set to proposed, the expiry time and the approver group.
- Step 4: Post the card to the designated Slack channel or direct message, with approve and reject buttons whose values contain only the request identifier and the chosen decision.
- Step 5: Receive the button interaction on a server you control, verify that the request really came from Slack using the signature check Slack provides, and load the stored request by identifier.
- Step 6: Check that the clicking user is on the approver list in your system. Membership in the channel is not enough.
- Step 7: If the request is still proposed and not expired, move it to approved and pass the stored payload, with an idempotency key, to the executing service.
- Step 8: Record the outcome, update the Slack message to show the decision and the result, and send any rejection reason back to the agent.
Keep steps 5 through 7 in code that you test directly. Do not rely on the Slack client to enforce the rules. A button click is only a signal.
Designing the buttons and the expiry rules
Two buttons are usually enough: approve and reject. A third option, such as "ask for changes," can be useful when the approver wants the agent to revise a proposal, but it should create a new request rather than editing the old one in place. Editing an approved payload in place is how a reviewed action quietly becomes a different action.
Expiry needs a deliberate default. A request that nobody reads should not remain live indefinitely, because the business context may have changed by the time someone clicks. Choose a window that matches the urgency of the action class, and make expiry fail closed: the request moves to expired, nothing executes, and the agent is told that the proposal lapsed. If the action is still needed, the agent can propose it again with current evidence.
Idempotency matters here as well. Slack can deliver the same interaction more than once, and people double-click. The executing service should treat the request identifier as the key, so a second approval for an already executed request returns the original result instead of creating a second record. Stripe's documentation on idempotent requests shows the provider-side version of this principle, and the same reasoning applies to your internal write operations.
Finally, decide what happens to a request when the underlying data changes before approval. A simple rule works well: if the target record has been modified since the proposal was created, the request is marked stale and must be regenerated. Approval should always refer to a known state of the world.
Illustrative scenario: a supplier payment hold
The following scenario is illustrative and does not describe a real client.
A small distribution company uses an agent to read supplier statements and prepare payment batches. The agent notices a duplicate invoice in a statement and proposes placing a hold on one line in the accounting system. Its request card shows the two invoice numbers, the matching amounts, the source statement attached as a read-only file and a note that the agent cannot confirm whether the second invoice was credited. The risk level is marked as financial, the expiry is set to end the same business day, and the approver group is the finance lead and one deputy.
The finance lead opens the card, sees the evidence, and rejects the hold with the reason that the credit note is pending. The agent receives the reason, records it against the supplier, and does not propose the hold again until the credit note appears in the statement. Nothing in the accounting system changed during the exchange, and the decision trail shows who decided and why.
The value of this flow is not that the agent was wrong or right. It is that the person with authority saw the evidence and made the call before the system changed.
Common failure modes and how to avoid them
Several problems appear again and again in these setups. Knowing them in advance saves rework.
- Approval by channel membership: anyone in a busy channel can click. Fix this with a server-side approver list tied to roles.
- Regenerated payloads: the agent rewrites the action between the card and the click. Fix this by executing only the stored proposal.
- Silent expiry: requests lapse with no notice, and the business assumes the work was done. Fix this by notifying the requester and updating the Slack message.
- Overloaded channels: every low-risk task posts a card, and approvers start clicking without reading. Fix this by routing only the action classes that truly need a decision, and reviewing the list regularly.
- Permission creep: the executing service receives broad write access because it was easier to configure. Fix this by granting the executor only the operations it needs, a pattern the OWASP authorization guidance supports through checks enforced on the server side.
- Unclear ownership: nobody knows who maintains the approval rules after launch. Assign that role explicitly and review the rules when a tool or process changes.
Agent builders often focus on the model and underestimate the operational surface. Anthropic's guidance on building effective agents describes the value of deliberate checkpoints where a human can intervene, and in practice those checkpoints are the parts that need the most maintenance.
How Be Human handles approvals in managed operations
Be Human designs approval flows as part of the agent's operating context from the first engagement. The first engagement defines the single role, the tools and memory it needs, the action classes that require a person, and a success criterion that can be observed, such as the proportion of proposals approved without revision, reviewed over time. Approver groups, expiry rules and the stored request model are set up with your team and tested against real proposals before any write is enabled.
In managed operations, the same work continues after launch. Permission reviews check whether approver lists and executor scopes still match the business, recurring evaluations sample approved and rejected requests to see whether the cards carry enough evidence, and integration maintenance keeps the Slack and system connections current when either side changes. When an approval path fails, incident response restores the fail-closed state first and then investigates the cause.
The approach is deliberately conservative. A proposal can be useful even when its approval rate is low, because rejections reveal where the agent's context is incomplete.
Choosing the first action to route through Slack
The best first approval flow is usually narrow: one action, one approver group, one system, and a card that a busy person can read in under a minute. Pick an action where a wrong write is costly but the evidence is easy to show, and where the business already has a clear owner who would say yes or no. Once that flow runs reliably, adding a second action class is a matter of extending the same pattern rather than designing a new one. If you are not yet sure which task deserves that first slot, take the free Be Human AI diagnostic to find the first task worth handing to an agent.
Frequently asked questions
Can an AI agent click approve in Slack on its own? No, the approval must come from a person on your approver list, and the agent should only ever create the proposal. Your server verifies the interaction and checks the clicking user against your own records, so the agent has no path to self-approval. If the agent also posts the card, it should use an account with no approval rights.
What happens if the approver is on holiday and the request expires? The request moves to expired, nothing executes, and the requester is notified in the same thread. If the action still matters, the agent can create a fresh proposal with current evidence, and a backup approver group can be defined in advance for predictable absences. Expiry is a safety feature, so it should be treated as correct behavior rather than an error.
Should the approval card include the full raw data from the source system? Usually not. Include the fields needed for the decision, the exact payload that will be executed, and links to read-only views of the evidence. Pasting entire records makes cards hard to read, increases the chance of exposing personal data in a chat channel, and encourages approvers to skim.
Is Slack the right place for this, or should approvals happen inside the business system? Slack works well when the approver is already there and the decision is quick, while an in-system queue suits high volume or detailed review. Many teams start in Slack and move to a richer queue later, keeping the same request model so the change does not alter the agent's behavior. The channel choice is covered in more depth in Slack or Teams for AI Agents: Which Channel Fits Best?.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


