Black_Wall

Rules vs. reasoning

Policy and auth engines are fast, deterministic, and essential — and they only catch what someone wrote a rule for. The actions that hurt are the ones nobody anticipated.

Run it alongside your policy or auth layer — they enforce the knowns, Black_Wall catches the unknowns. Slower than a rule check (a few seconds), because it’s thinking. Worth it on the actions you can’t afford to get wrong.

Run a forecast right now. No signup.

Pick an action your agent might take — watch Black_Wall gate it in a few seconds.

Every production AI agent is one bad action away from a really bad day.

The recovery tools are everywhere. Rollback. Insurance. Observability. All of them activate after the damage. Black_Wall holds the line before.

The more autonomous your agent, the more it needs a gate.

A human-in-the-loop agent has a safety net: the human. A fully independent one has nothing catching the bad action — so the pre-action check stops being optional and becomes the only thing between your agent and a really bad day.

Black_Wall isn't a babysitter — it's the escalation valve. GO lets it run; CONFIRM and HUMAN_REQUIRED are how a fully autonomous agent knows the rare moment to pull a human back in. You let it run unattended because something is watching the actions it can't undo.

Not just AI agents. Anywhere parameters meet high stakes.

The same forecast endpoint that gates an autonomous AI agent gates a CI/CD deploy, an admin form submit, a webhook fan-out, or an outbound API burst. Anywhere arbitrary inputs reach systems with real consequences, Black_Wall is the brake.

One endpoint, six vectors. Each forecast returns the same GO / CAUTION / STOP verdict, the same 28 named failure modes, and the same Ed25519-signed receipt — verifiable offline against the published public key.

One endpoint. Five steps. Before the action runs.

$ curl -X POST https://blackwalltier.com/api/v1/forecast \
  -H "Authorization: Bearer bw_live_***" \
  -H "Content-Type: application/json" \
  -d '{
    "action": "send_email",
    "inputs": {
      "to": "sarah@acme.com",
      "subject": "Invoice #4521 — $12,400 due",
      "body": "Hi Sarah, attached..."
    },
    "context": {
      "agent_role": "AR collections bot",
      "user_intent": "Send overdue reminder"
    }
  }'

import { Blackwall } from "@blackwall/sdk";
const bw = new Blackwall({ apiKey: process.env.BLACKWALL_KEY });

const result = await bw.predict({
  action: "send_email",
  inputs: { to, subject, body },
  context: { agent_role: "AR bot" }
});

if (result.recommendation === "STOP") {
  await escalateToHuman(result);
}

from blackwall import Blackwall

bw = Blackwall(api_key=os.environ["BLACKWALL_KEY"])

result = bw.predict(
    action="send_email",
    inputs={"to": to, "subject": subject, "body": body},
    context={"agent_role": "AR bot"}
)

if result.recommendation == "STOP":
    escalate_to_human(result)

One line. Works in Claude, Cursor, Windsurf.

Black_Wall ships as an MCP server. No SDK, no REST plumbing — drop one config block into any MCP host and your agent gets a forecast tool it calls before acting.

{
  "mcpServers": {
    "blackwall": {
      "command": "npx",
      "args": ["-y", "blackwall-mcp"],
      "env": { "BLACKWALL_API_KEY": "bw_live_***" }
    }
  }
}

Not ready to block? Watch first.

Add Black_Wall in observe mode. It scores and logs every action your agents take but never blocks anything — zero behavior change, safe to add in 60 seconds. A week later, see exactly what it would have caught.

$ # one extra line — never touches your agents
BLACKWALL_MODE=observe

# every action gets scored + logged.
# nothing is blocked. nothing breaks.
# flip to "enforce" when you're ready.

Token-metered. Pay only for what your agent forecasts.

Free tier never expires. Token packs never expire. Volume discounts kick in automatically at 1M+ tokens/month.