Antaeus review: turn written policy into versioned, testable decisions

Most teams keep their content and onboarding rules in two incompatible places: a terms page written for humans, and a pile of if statements buried in application code that nobody can fully explain six months later. Antaeus is an attempt to collapse that gap. It takes a written policy, turns it into a versioned artifact with named test cases, and returns an explicit decision your app can act on. It is early and open source, and the project is refreshingly blunt about what it is not.

What Antaeus actually does

The core idea is "semantic policy enforcement": judging whether a piece of content or a proposed action complies with a policy that was written in plain language, where the answer depends on interpretation rather than a lookup. Think "does this marketplace listing violate our prohibited-items rule" or "does this vendor submission meet our onboarding terms" — questions a regex can't settle honestly.

You send content and a policy; Antaeus returns a Decision with one of four outcomes: allow, review, deny, or failure. Two design choices make this more than a wrapper around a language model. First, the evaluator only reports whether each policy condition applies — Antaeus then applies the policy's own outcomes deterministically, so the final verdict follows rules you wrote, not a model's mood. Second, every Decision records the evaluator, the model, and the attempt count, and each policy carries a version. That is the part a compliance or trust-and-safety team usually can't get from a raw model call.

The scope discipline is the most reassuring thing on the site. The docs state plainly that Antaeus "does not replace authentication, authorization, deterministic business rules, transactions, or application side effects," and that "if a rule can be written safely as ordinary code, it does not belong in Antaeus." A tool that tells you where not to use it is a tool built by people who have watched this category overreach.

The open-source core and the hosted beta

There are two ways in, and they have very different maturity.

The open-source engine is a Go core and CLI under an Apache-2.0 license. You can run it locally with no account and a credential-free quickstart, validate policies, evaluate content, and run regression tests against your own fixtures. Installation is the usual developer menu — Homebrew (brew install antaeusio/tap/antaeus), go install on Go 1.26 or newer, a container image, or signed release archives that ship with SHA256SUMS and build-provenance attestations. Semantic evaluation itself is still labelled experimental: you can bring your own OpenAI key, point it at a self-hosted CLM server, or use a CPU-only NLI evaluator, and the v0.5.0 release even compiled the engine to WebAssembly so JavaScript hosts can run it with their own fetch transport. The GitHub history backs up the "active" claim, with releases marching from v0.1.0 to v0.6.0 and commits landing within the last few days of this writing.

The hosted beta is where you get API keys, managed policies, a playground, and an MCP server that exposes a check_intent call so an agent can test a proposed action against an approved policy before it runs. That MCP hook is the detail worth flagging for anyone building autonomous agents: it is a natural place to put a policy gate. The catch is that the hosted side is explicitly a beta with shared capacity and no production SLA.

How pricing works

Pricing is unusually transparent for a beta, and it avoids the subscription trap. You start on free capacity, then buy one-time prepaid credit in $10, $25, or $100 blocks through Dodo, with no recurring charge and no automatic top-ups. Paid usage only starts after the workspace owner opts in.

The metered rate, as of November 2026, is $0.001 per billable Decision plus $0.000001 per validated input token, capped at $0.05 per request. A Decision with 1,000 validated input tokens works out to $0.002. Replays, failure decisions, and operational failures are not charged, and you can turn paid usage off at any time, with unused-credit refunds handled back through Dodo. For a team evaluating whether this fits a workflow, the prepaid model means you can cap your exposure at ten dollars and find out.

Where it still shows its age

The honest caveats are mostly about maturity, not design. The project was created in September 2026 and sits at version 0.6.0 with a single-digit GitHub star count, so there is no independent review record and no community war stories to lean on yet. The headline workflow on the current homepage — a public registry where you publish and share a citable policy version, with four document-onboarding paths — is marked in development. What you can use today is the local engine, private managed policies, and the hosted checks API; the publishing experience is a preview.

There is also the unavoidable nature of the problem. Semantic checks are probabilistic, and an independent write-up from Zuplo on semantic gateway policies makes the fair point that testing whether a policy correctly handles every phrasing of a sensitive request is fundamentally harder than testing conventional rules, and that a model version or threshold change can quietly shift behavior. Antaeus's answer — versioned policies, named test cases, explicit failure outcomes, and recorded evaluator metadata — is exactly the right posture for that risk, but the test coverage is still yours to own, and the OpenAI evaluator path means sending content to OpenAI on your own key.

Overall this is a 3 out of 5: well-engineered, honest about its boundaries, and genuinely useful to run locally today, but early enough that betting a production trust-and-safety pipeline on the hosted beta would be premature.

Who should try it

Antaeus fits engineering and trust-and-safety teams who want policy logic to live in a testable, versioned artifact instead of scattered code, and agent builders who want a policy gate they can call before an action executes. It is a poor fit if you need a production SLA now, or if your rules are deterministic enough to express as plain code — which, to its credit, is the first thing the project tells you. Clone the repo, run the local quickstart, and model one real policy against your own test cases before you touch the hosted side.

Sources consulted

• Antaeus llms.txt — project overview, scope, install methods, evaluator options, and release history
• Antaeus prepaid pricing — prepaid credit tiers, per-decision rate, opt-in and refund mechanics
• How Antaeus works — current hosted checks vs the in-development registry and onboarding paths
• antaeusio/antaeus on GitHub — license, language, release cadence, and repository activity
• Zuplo: semantic vs programmatic API gateway policies — independent perspective on the testing challenges of semantic policies