Which policy decided this?
Identify the exact authored artifact, configuration, and evaluator route instead of reconstructing them from a prompt.
Semantic policy infrastructure, in the open
Make semantic policy decisions inspectable.
Turn human-written policy into versioned artifacts, named tests, explicit outcomes, and evidence your application can consume. Antaeus is early: try it free in the browser, or run the open-source engine locally, credential-free, with an experimental bring-your-own-key OpenAI evaluator.
The operating problem
A prompt can answer once. Policy has to survive change.
Meaning-heavy decisions often begin inside application code. Operating them responsibly means answering three questions long after the first response looked plausible.
What changed?
Exercise named cases against a policy version before a wording change reaches an application decision.
What happens when evaluation fails?
Keep uncertainty, review, denial, and operational failure distinct so an outage does not silently become policy.
A narrow boundary by design
A semantic decision engine—not your auth stack.
Antaeus is for bounded questions that require interpretation of language, intent, context, or exceptions. Deterministic requirements should stay in deterministic code.What is semantic policy enforcement?
Antaeus owns
Policy evaluation
Versioned policy artifacts, named cases, evaluator boundaries, explicit outcomes, and traceable evidence.
Your application owns
System authority
Authentication, authorization, deterministic rules, transactions, side effects, and the action taken after a decision.
People own
Accountability
Policy intent, exceptions, review, escalation, and responsibility for consequential choices.
The policy lifecycle
Move policy out of the prompt and into an operating model.
The current core establishes the local contract. Semantic adapters, starting with an experimental OpenAI evaluator, and behavioral comparison must earn their place against the same explicit artifacts and failure semantics.
- 01
Available locally
Author and validate
Write constrained YAML or JSON against a versioned schema, then derive a canonical identity for the exact policy.
- 02
Available locally
Test named cases
Bind inputs and expected outcomes to the policy version so contract changes are visible instead of anecdotal.
- 03
Contract available
Choose an evaluator route
Keep policy meaning separate from provider configuration, credentials, fallback, and deployment-specific choices.
- 04
Fixture available · experimental semantic evaluator
Evaluate explicitly
Return allow, review, deny, or failure through one provider-neutral decision contract. The quickstart route is synthetic; an experimental OpenAI adapter evaluates real conditions with your own key.
- 05
Decision evidence available · comparison planned
Inspect and compare
Trace the policy and evidence behind a decision; later, compare policy versions before publishing a behavioral change.
Current proof
Run the contract before trusting the story.
The public quickstart validates one real policy artifact, evaluates an exact synthetic case, and runs the same case through the portable regression contract. It reads no credential and makes no network call.
$ .tmp/bin/antaeus validate vendor-onboarding.yaml
policy digest verified · 2 rules
$ .tmp/bin/antaeus evaluate --case aggregate-analytics
policy vendor-onboarding
mode deterministic-fixture
outcome review
network none
credentials none
$ .tmp/bin/antaeus test --suite quickstart.json
named regression case matchedIllustrative summary of the exact checked-in public example; file paths and JSON output are shortened for readability.
Explicit terminal states
Failure is not a synonym for deny.
Applications need enough information to choose an appropriate next step. Every state has a name and meaning; color is only a supporting cue.
Allow
The policy and evaluated evidence support proceeding.
Review
The policy requires accountable human review or reaches its declared review default.
Deny
The policy and evaluated evidence support refusing the requested case.
Failure
Evaluation could not produce sufficient evidence; the application decides how to handle that operational state.
Open by default
Start with code and contracts you can inspect.
The Antaeus core is intended to remain useful without a hosted account. The repository holds the policy and decision schemas, Go packages, command-line workflow, examples, governance, and Apache-2.0 license.
The latest release, v0.6.0, installs with Homebrew, go install, or a container image. The semantic evaluator is experimental. The hosted beta offers API keys, managed policies, and prepaid usage, with shared capacity and no production SLA.
A separate research track
The implementation is not the result.
Semantic Policy Enforcement asks whether meaning-heavy policies can be evaluated with useful quality, review boundaries, cost, and reproducibility. That requires frozen inputs, declared thresholds, and evidence—not a roadmap or a polished demonstration.
No empirical result is published yet. Antaeus is the reference implementation used to make the eventual experiment inspectable.
Understand the research boundaryStart with current proof
One policy. One named case. No credentials.
Run the local fixture workflow, inspect the resulting decision, and decide whether the contract fits the boundary your application needs.