canonical: https://jentic.com/apis/negativeev.com/negativeev

# NegativeEV bet checker

The NegativeEV bet checker API grades a sports bet by simulating the game thousands of times, play by play, and comparing how often the bet would have won with the probability the sportsbook's price implies. A bet such as 'Shohei Ohtani over 1.5 total bases -120' is sent as plain text in an A2A JSON-RPC SendMessage call, and the reply carries a text summary of the verdict plus a data part with the full result. Two GET operations report whether a simulated slate exists for the day and how many checks the caller has left, and signed-in members can mint and revoke nev_ agent keys.

## For AI agents

Grade a sports bet against play-by-play game simulations, check whether today's slate has been simulated, and read the remaining check allowance.

## Scope

Does not place bets, quote live odds, or hold sportsbook accounts. Use for grading a priced bet against game simulations only.

## Capabilities

- Grade a bet written as plain text, such as a player prop with its American odds, against simulated outcomes of the game
- Receive a verdict as a short text summary plus a structured data part carrying the full result
- Check whether a simulated slate exists for the current game_date before spending a check
- Read the caller's allowance: limit, used, remaining, and seconds until the window resets
- Mint, list, and revoke nev_ agent keys that carry a signed-in member's allowance

## Use cases

### Betting assistant that sanity-checks a bet

A user asks their AI assistant whether a bet is worth placing. Through Jentic the agent searches for 'grade a sports bet', loads the NegativeEV A2A SendMessage operation with its input schema, and sends the bet as the text part of a user message. The reply's text part summarises the verdict and its data part carries the full result, so the agent answers with the simulated win rate against the price's implied probability rather than an opinion.

Example prompt: Call GET /slate to confirm available is true, then POST /a2a with method SendMessage and the text 'Shohei Ohtani over 1.5 total bases -120', and report the verdict

### Spending checks only when there is a slate

Checks are metered, anonymous callers per device per day and signed-in callers per hour, so an agent should not spend one on a day with no simulations. The slate operation answers before a bet is sent with available, game_date, and model_date, and the usage operation returns limit, used, remaining, and reset_in so the agent can tell the user when checks refill.

Example prompt: Call GET /usage and GET /slate, and only grade the bet if remaining is above zero and available is true

### Agent keys for a member's own assistant

A signed-in NegativeEV member wants their own agent to run checks under their membership. With a Supabase session token they mint a named nev_ agent key, whose plaintext is shown once and stored only as a hash. Keys can be listed with their prefix and last_used_at, and revoked by id when an assistant is retired.

Example prompt: Call POST /keys with name 'betting-assistant', store the returned key, then later revoke it with POST `/keys/revoke` using its id

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/a2a` | Grade a bet via A2A SendMessage |
| GET | `/slate` | Check for a simulated slate |
| GET | `/usage` | Read remaining checks |
| POST | `/keys` | Mint an agent key |
| GET | `/keys` | List agent keys |
| POST | `/keys/revoke` | Revoke an agent key |

## Key resources

- **Bet grading** — A2A JSON-RPC SendMessage that takes a bet as text and returns a verdict summary and full data
- **Slate** — Whether a simulated slate exists, with game_date and model_date
- **Usage** — The caller's check allowance and time until the window resets
- **Agent keys** — Mint, list, and revoke nev_ agent keys for a signed-in account

## 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:** 75 / 100
- **Maturity:** AI-Ready
- **Dimensions:**
  - Foundational Compliance: 90 / 100
  - Developer Experience & Jentic Compatibility: 70 / 100
  - AI-Readiness & Agent Experience: 65 / 100
  - Agent Usability: 94 / 100
  - Security: 68 / 100
  - AI Discoverability: 73 / 100
- **View full report:** https://jentic.com/apis/negativeev.com/negativeev/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 NegativeEV by hand means building A2A JSON-RPC envelopes with message ids and roles, telling a Supabase session token apart from a nev_ agent key, and reading the slate and allowance before each check. Through Jentic you install once, import NegativeEV from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** NegativeEV carries the bet and the key id inside the request body, so rules bound which operations your agent may call, not which bet or key. Limit the agent to the operations it needs, such as grading and the slate check, so key minting and revocation are not included unless you add them.
- **Credential handling:** Your NegativeEV agent 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 'grade a sports bet' or 'check remaining bet checks', and Jentic returns the matching NegativeEV operation with its input schema so the agent sends a well-formed JSON-RPC message.

## Related APIs

- **The Odds API** — Live sportsbook odds to find the prices worth checking
- **SportsData.io NFL API** — Sports schedules, stats, and results data
- **Odds API** — Odds data feed where the agent computes value itself

## FAQ

### What authentication does the NegativeEV bet checker use?

Per its OpenAPI spec, the grading, slate, and usage operations can be called anonymously, metered per device, or with a bearer token that raises the allowance: either a Supabase access token (a JWT) or a nev_ agent key. The key-management operations under /keys require the Supabase session token, so a key can never mint another key. Through Jentic the token is stored encrypted by your own instance and attached per call.

### How do I send a bet to be graded?

POST /a2a with a JSON-RPC 2.0 body whose method is SendMessage and whose message has a user-role text part holding the bet, for example 'Shohei Ohtani over 1.5 total bases -120'. The reply is an agent message: its text part summarises the verdict and its data part carries it in full.

### What are the rate limits for the NegativeEV bet checker?

The spec meters checks rather than requests: anonymous callers get an allowance per device per day and signed-in callers per hour. It does not publish the numbers, but GET /usage returns your current limit, used, remaining, and reset_in, and a refused call returns an error code such as out_of_checks or rate_limited.

### Is there a NegativeEV MCP server?

Yes - NegativeEV serves an MCP endpoint at POST /mcp with check_bet, get_slate, and get_usage tools. You can also connect it directly through Jentic: your agent gets the full 7-endpoint surface without loading another server's tool definitions into its context, your token is injected at call time by your self-hosted instance instead of living in a config file, and your rules decide which operations the agent may call.

### How do I grade a bet with NegativeEV through Jentic?

Import NegativeEV from the API Directory in your Jentic One instance and store your nev_ agent key. Your agent searches for 'grade a sports bet', loads POST /a2a, and sends the bet as message text after a quick GET /slate. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Can I limit what my agent is allowed to do with NegativeEV?

Yes. Write a rule that allows only POST /a2a, GET /slate, and GET /usage, and the agent can grade bets and watch its allowance but cannot mint or revoke agent keys. Every call it makes is logged.