DEV Community

HaveAGoodOne
HaveAGoodOne

Posted on

AI Has Hands Now. You Should Decide What It Can Do.

We’ve crossed a line.

AI is no longer just generating text.

It’s starting to take actions.

Your agent can now:

  • call APIs
  • delete data
  • send emails
  • trigger workflows
  • modify production systems

And in most setups today, it does all of that without a control layer.

The uncomfortable truth

Most AI agents today operate like this:

await deleteUser(userId);
await sendEmail(customer);
await transferFunds(amount);
Enter fullscreen mode Exit fullscreen mode

If the agent decides to do it — it just… runs.

No checkpoint.
No approval.
No policy enforcement.

That’s fine in a demo.

It’s not fine in production.

This is where things break

The moment your AI touches real systems, you’re exposed to:

  • Accidental destructive actions
  • Prompt injection leading to unintended behavior
  • Over-permissioned tools
  • No audit trail of decisions

You don’t need a malicious AI.

You just need:

a slightly wrong decision, at the wrong time, in the wrong environment

The missing layer: decision before execution

What’s missing is simple:

Every action should be checked before it runs.

Not after.
Not in logs.
Not in alerts.

Before execution.

Introducing Runplane

Runplane adds a runtime control layer between your AI and real-world actions.

Instead of executing immediately, every action goes through a decision:

  • ✅ ALLOW
  • ❌ BLOCK
  • ⏸ REQUIRE APPROVAL

What this looks like in practice

Without control:

await deleteUser(userId);
Enter fullscreen mode Exit fullscreen mode

With Runplane:

await runplane.guard(
  "delete_user",
  "production-db",
  { userId },
  async () => {
    return deleteUser(userId);
  }
);
Enter fullscreen mode Exit fullscreen mode

Now that action can:

  • be blocked
  • require human approval
  • be logged and audited

This is not just theory

If you’re building:

  • AI agents
  • automation workflows
  • MCP-based tools
  • internal copilots
  • API-triggering systems

You already have the problem.

You just haven’t felt it yet.

Built for modern AI architectures (including MCP)

Runplane fits directly into current AI stacks:

  • Works alongside agent frameworks
  • Supports MCP-style tool execution flows
  • Sits between the model and the tool call
  • Does not require changing how your tools work

It doesn’t replace your agent.

It controls what your agent is allowed to do.

Why this matters now

We’re moving from:

“AI suggests actions”

to:

“AI executes actions”

That shift changes everything.

Execution without control is risk.

Try it (free developer tier)

We opened a free developer tier so you can test this in real flows:

https://runplane.ai/auth/sign-up?mode=developer

You can:

  • integrate in minutes
  • simulate risky actions
  • test approval flows
  • see exactly how decisions affect execution

Final thought

You don’t need to wait for a disaster to add control.

By the time something breaks, it’s already too late.

AI has hands now.

You should decide what it’s allowed to touch.

Top comments (0)