canonical: https://jentic.com/apis/overwing.ai/overwing

# Overwing API

The Overwing API checks what AI agents say and do before it takes effect, across five products in one surface. Guardrails evaluates text against a rule set and returns a pass, fail, or review verdict per rule with one recommended action such as block, redact, review, or allow; Preflight checks an unsigned Solana transaction against the caller's policy and answers allow or refuse before an agent signs it. Atlas is a registry of AI crawlers and browser agents with a lookup that says what a User-Agent claims to be and whether that claim can be verified, Beacon reports whether a site is reachable by agents, and Tower runs typed operations on legacy business systems where each write is executed, queued for human review, or refused, with a signed receipt.

## For AI agents

Evaluate text against Overwing guardrail rule sets, check an unsigned Solana transaction against a policy before signing, identify a User-Agent in the Atlas registry, run a Beacon agent-reachability check on a site, or submit Tower actions that are executed, reviewed, or refused with signed receipts.

## Scope

Does not sign or broadcast Solana transactions, host language models, or block crawlers at the network edge. Use for checking agent text, transactions, User-Agents, site reachability, and reviewed actions against Overwing policies only.

## Capabilities

- Evaluate text against a rule set slug through `/api/v1/evaluate` and get per-rule verdicts with a recommended block, redact, review, or allow action
- Evaluate up to 50 inputs against one rule set in a single call through `/api/v1/evaluate/batch`
- Create, update, and deactivate custom guardrail rule sets by slug
- Check an unsigned Solana transaction against a policy with `/api/v1/preflight/checks` before an agent signs it
- Identify what a User-Agent string claims to be and whether the claim is verifiable with `/api/v1/atlas/lookup`
- Start a Beacon check on a URL to report whether agents can find, read, and use the site
- Submit Tower actions with an operation, input, and idempotency_key, then read their status, receipts, and run compensating operations

## Use cases

### Agent output checks through Jentic

Before an agent sends a drafted message, it calls the Overwing evaluate operation through Jentic with the draft as input and a rule set slug. The response carries a verdict per rule and one recommended action, so the agent can send, redact, or route the draft to a person. Your own Jentic One instance injects the Overwing key at call time, and a rule can keep the agent to evaluation operations only.

Example prompt: POST `/api/v1/evaluate` with input set to the drafted customer reply and rule_set 'pii-basic', then follow the recommended action in the response

### Transaction policy checks before signing

Agents that hold a Solana wallet need a check between building a transaction and signing it. The preflightCheck operation takes the unsigned transaction and a policy and answers allow or refuse with reason codes, and each verdict has a public record at `/api/v1/preflight/checks/{id}` that later reports of the landed transaction are filed against.

Example prompt: POST `/api/v1/preflight/checks` with the base64 unsigned transaction and a policy limiting the transfer amount, then sign only if the verdict is allow

### Identifying agent traffic with Atlas

Site operators seeing new bots in their logs want to know what each one is. The atlasLookup operation takes a user_agent and returns what it claims to be and whether that claim can be verified, and the Atlas registry lists crawlers, fetchers, and browser agents with public fields for each entry.

Example prompt: GET `/api/v1/atlas/lookup` with user_agent 'Mozilla/5.0 (compatible; GPTBot/1.1; +https://openai.com/gptbot)' and report whether the claim is verified

### Reviewed writes to legacy systems with Tower

Tower puts a policy and approval step in front of writes to older business systems. An agent submits an action with an operation, input, and idempotency_key; Tower executes it, queues it for review, or rejects it, and every step yields a receipt whose signatures can be checked with the published Ed25519 public key. Tower is in pilot against a mock adapter.

Example prompt: POST `/api/v1/tower/decide` with the order-entry operation and input to preview the policy outcome, then POST `/api/v1/tower/actions` with the same operation, input, and a new idempotency_key and poll GET `/api/v1/tower/actions/{id}`

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/v1/evaluate` | Evaluate text against a rule set |
| POST | `/api/v1/evaluate/batch` | Evaluate up to 50 inputs |
| POST | `/api/v1/rule-sets` | Create a custom rule set |
| POST | `/api/v1/preflight/checks` | Check an unsigned Solana transaction |
| GET | `/api/v1/atlas/lookup` | Identify a User-Agent string |
| POST | `/api/v1/beacon/checks` | Start an agent-reachability check |
| POST | `/api/v1/tower/actions` | Request a Tower action |
| GET | `/api/v1/tower/receipts/verify` | Verify receipt hashes and signatures |

## Key resources

- **Guardrails** — Single and batch evaluation, stored evaluations, and custom rule sets
- **Preflight** — Policy checks on unsigned Solana transactions with public verdict records and miss reports
- **Atlas** — Agent registry browsing, User-Agent lookup, sightings, datasets, and registrations with domain proof
- **Beacon** — Agent-reachability checks for a URL with saved reports
- **Tower** — Agent identities, capabilities, policy decisions, actions, compensation, and signed receipts
- **Account** — Signup, API keys, webhook, organization settings, usage, audit log, and billing

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 61 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 74 / 100
  - Developer Experience & Jentic Compatibility: 63 / 100
  - AI-Readiness & Agent Experience: 44 / 100
  - Agent Usability: 87 / 100
  - Security: 60 / 100
  - AI Discoverability: 63 / 100
- **View full report:** https://jentic.com/apis/overwing.ai/overwing/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Overwing by hand means handling ow_live_ bearer keys and their full or evaluate scope, separate agent keys for Tower, and knowing which reads are open or paid per call. Through Jentic you install once, import Overwing from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Overwing carries the evaluation target in the request body and the rule set as a slug, so rules bound which operations your agent may call rather than which input. You choose the operations, so destructive ones like deleteOrganization, purgeEvaluations, or createApiKey are not included unless you add them.
- **Credential handling:** Your Overwing key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'check text against guardrail rules' or 'check a Solana transaction before signing', and Jentic returns the matching Overwing operation with its input schema so the agent sends the right fields.

## Related APIs

- **Lakera API** — Prompt injection and unsafe content screening for LLM inputs and outputs
- **Fingerprint Pro Server API** — Visitor identification and fraud signals for web traffic
- **OpenAI API** — Model API whose outputs can be checked by Overwing before they are sent

## FAQ

### What authentication does the Overwing API use?

Per its OpenAPI spec, most Overwing operations use the bearerAuth scheme: an API key in the form ow_live_ followed by hex, sent as a bearer token and issued from the dashboard, POST `/api/v1/api-keys`, or POST `/api/v1/signup.` A key is scoped either full or evaluate, and Tower actions take an agent key. Many reads are declared open, such as the Atlas registry, plans, and Preflight records, and evaluate and Atlas lookup also work without a key at a small daily limit. Through Jentic the key is stored encrypted by your own Jentic One instance and injected at call time.

### Can I evaluate many inputs at once with Overwing?

Yes. POST `/api/v1/evaluate/batch` evaluates up to 50 inputs against one rule set in a single call. For a single input, POST `/api/v1/evaluate` requires input and rule_set and accepts metadata, context, and a store flag, plus an Idempotency-Key header for safe retries.

### What are the rate limits for the Overwing API?

The spec states that POST `/api/v1/evaluate` and GET `/api/v1/atlas/lookup` work with no key for 10 calls a day each. Keyed limits depend on your plan: GET `/api/v1/usage` returns daily usage and remaining quota, and GET `/api/v1/plans` lists plan limits and prices.

### How do I check an agent's draft against a rule set through Jentic?

Install Jentic One, add the Overwing API from the Jentic API Directory, and store your Overwing key once. Your agent searches for 'check text against guardrail rules', gets the evaluate operation with its input schema, and calls POST `/api/v1/evaluate` with input and rule_set. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Is there an Overwing MCP server?

Yes - Overwing's own spec says the same operations are offered over MCP, hosted at its /mcp path and as an npm package. You can also connect the Overwing API directly through Jentic: your agent gets the full 90-endpoint surface from the spec without loading another server's tool definitions into its context, your key is injected at call time by your self-hosted instance instead of living in an MCP config, and your rules decide which operations the agent may call.

### Can I limit what my agent is allowed to do with the Overwing API?

Yes. Write a rule that allows only POST `/api/v1/evaluate` and POST `/api/v1/evaluate/batch`, and your agent can check its drafts but cannot edit rule sets, mint API keys, change the webhook, or delete the organization. Your own Jentic One instance keeps an audit log of what it called.