Control what your AI is allowed to do. Prove every decision it makes.
Swiftward™ is the enterprise-grade control plane for AI. Write your policy as versioned code and test it against real traffic before it goes live. Replay a decision later on the exact policy version that was live, when someone disputes it. Runs on your infrastructure. Nothing leaves your environment.
Built by Konstantin Trunin, who ran this same declarative architecture - a high-load logistics platform - in production for years, and is building it a second time, for policy. Konstantin on LinkedIn →
rules:
deny_unpermitted_tool: # role-based tool control
all:
- path: "event.type"
op: eq
value: "tool_call"
- path: "signals.tool_allowed"
op: eq
value: false
effects:
verdict: rejected
priority: 100
response:
blocked: true
reason: "Tool not permitted for this agent's role" The engine decides automatically. It keeps a human in the loop only for the calls it flags. Replay the disputed.
Every decision your AI makes runs through one engine, on a policy you version like code. You choose how each call is made: a fast deterministic rule, a model's judgment, or a human in the loop. The engine itself is deterministic, so the decisions you build that way replay exactly. When a customer, an auditor, or a regulator asks what happened months later, you do not reconstruct it from logs. You replay it on the policy version that was live.
Enterprise-grade from day one.
Most policy tooling is built SaaS-first, with enterprise bolted on later. Swiftward is the other way around. On-prem, SSO, role- and attribute-based access, multi-tenancy, secrets management, and an append-only audit trail are built in. These are the controls your customers' security reviews ask for first. Embed Swiftward under your own product and walk into that review with them already in place, instead of taking on years of platform work yourself.
Different problems, one engine.
Pick the one that is yours. Each runs on the same engine, with everything an enterprise buyer's security review demands underneath.
Control what your AI agents do: which tools they call, what data they touch, what actions they take. Prompt-injection defense, source-code and PII leak prevention, and a human in the loop for the calls that matter.
Enforce limits, approvals, velocity, and pre-trade checks on the decisions your AI makes, and replay any one of them for an examiner.
Moderate content with versioned policy, change it without a deploy, and replay any disputed takedown on the version that was live.
Embed Swiftward under your own product and walk into your buyers' security review with on-prem, SSO, access control, and audit already in place.
By industry, regulation, and protocol: Healthcare (PHI) · EU AI Act · Legal · Agent identity (ERC-8004)
Built for the standards and regulations your buyers and regulators care about.
One platform. Many controls. One engine underneath.
Underneath every use case is the same engine, on an enterprise foundation you run yourself. You are not buying a point tool. You are buying the engine every team shares.
See how this compares to assembling it yourself on OPA, LiteLLM, ROOST, or Microsoft's toolkit →
Real policies, one per problem.
Open the one that is yours: plain YAML, versioned, replayable. Every example below runs on the same engine.
signals:
tool_allowed:
udf: mcp/tool_allowed_for_roles
params:
tool: "{{ event.data.tool.name }}"
roles: "{{ event.data.context.roles }}"
role_permissions:
support: ["crm_read", "ticket_*"]
engineering: ["db_query", "github_*"]
admin: ["*"]
rules:
deny_unpermitted_tool:
all:
- path: "event.type"
op: eq
value: "tool_call"
- path: "signals.tool_allowed"
op: eq
value: false
effects:
verdict: rejected
priority: 100
response:
blocked: true
reason: "Tool not permitted for this agent's role"constants:
daily_refund_cap: 5000
state_models:
agent:
key: "{{ event.data.agent_id }}"
buckets:
refunds_today:
type: fixed_window # resets daily at 00:00 UTC
window: "24h"
timezone: "UTC"
rules:
track_refund:
all:
- path: "event.type"
op: eq
value: "agent_action"
- path: "event.data.action"
op: eq
value: "issue_refund"
effects:
state_changes:
agent:
change_buckets:
refunds_today: "{{ event.data.amount }}"
refund_over_daily_cap:
all:
- path: "event.type"
op: eq
value: "agent_action"
- path: "event.data.action"
op: eq
value: "issue_refund"
- path: "state.agent.buckets.refunds_today"
op: gte
value: "{{ constants.daily_refund_cap }}"
effects:
verdict: flagged
priority: 100
actions:
- action: hitl/create_case
params:
queue: "refund-review"
priority: 100
decision_types: ["approve", "reject"]
timeout_duration: "2h"
timeout_decision: "reject"rules:
repeat_offender:
all:
- path: "event.type"
op: eq
value: "ugc.post.created"
- path: "signals.toxicity_score"
op: gte
value: 0.9
- path: "state.user.counters.violations_30d"
op: gte
value: 3
effects:
verdict: rejected
priority: 100
state_changes:
user:
set_labels:
repeat_offender:
change_counters:
violations_30d: 1- Versioned policy lifecycle: draft, candidate, frozen, archived. One-click rollback.
- Shadow mode and A/B: test a change against live traffic before it affects anyone.
- Stateful decisions: counters, rate limits, sliding windows, circuit breakers.
- Dead-letter queue and replay: nothing gets lost.
- Gateways: LLM, MCP, network, FIX, SCM. Full decision traces and an append-only audit trail.
“The control plane for every consequential decision.”
Feature flags got their engine. Workflows got theirs. Policy, the decisions your software is not allowed to get wrong, still lives scattered across application code where no one can version it, test it, or prove it. Swiftward is the engine for that. Today the sharpest need is AI. The same engine governs any consequential decision your systems make.
Take a decision from months ago and re-run it on the exact policy version that was live when it happened. If its rules are deterministic, it reproduces exactly: the same verdict and the same record hash, every time. We will walk you through a live replay on a call; in a pilot, you run it on your own policies and your own traffic.
Pilots are underway with design partners.
A first call discusses your use case and shows how the engine would handle it, on a worked example.
Bring us the decision you need to control.
Start with a 30-minute call: tell us the decision you need to control, and we will walk you through how the engine would handle it, on a worked example.