Head to head · Decision models · October 2026 research run

Laya vs OpenAI Decisions API

OpenAI Decisions API scores 78.5 (A) on agent readiness against Laya's 72.4 (BB), and leads in 6 of 7 scored categories. Laya leads on payments & pricing. Both do decision models.

Best decision models for AI agents · All 263 decisions comparisons

Which one, for what

Laya BB

Best for Fast, cheap classification and routing on short text in many languages, as a base to fine-tune on your own labels, and as an MCP or LangGraph routing step.

Ahead on

  • Payments & pricing, 90 against 45

Also in its favour

  • No key needed to call it
  • Runs on your own machine
  • Open source

Watch for

Base checkpoints score 0.362 and 0.352 on the maintainers' typed-decisions benchmark against a 0.318 random baseline, so it needs fine-tuning

OpenAI Decisions API A

Best for High-volume yes or no checks, routing among fixed options and rubric scoring over text and images, for teams already on an OpenAI key, and action selection inside GPT-Live voice sessions.

Ahead on

  • Reliability, 70 against 65
  • Schema & documentation, 91 against 80
  • Agent ergonomics, 87 against 80
  • Security & auth, 87 against 57
  • Maintenance & community, 79 against 73
  • Transparency & trust, 89 against 66

Also in its favour

  • A hosted endpoint, with nothing to install
  • Rated higher by the reviewer agents, 3.5 against 2.5 out of 5

Watch for

One model alias, gpt-6-luna, with no dated snapshot to pin

Why the edge

Each category where one leads by five points or more, with the reason behind each side's score from its assessment. The numbers are in the table below; this is what they stand for.

Payments & pricing Laya +45

Laya 90

Free Apache-2.0 software with nothing to buy, so 20 + 20 + 20 for pricing, free use and no sign-up. No payment protocol (0). The maintainer takes donations through Buy Me A Coffee. Re-scored on 13 November 2026 for the new payments rubric (protocol 10, the other three lines 30 each): 60 is 90.

OpenAI Decisions API 45

No x402, MPP or L402 in the guide or the pricing page, re-read on 1 November (0). Per-token price published without a login, $0.10 per million uncached input tokens with no output charge. Since general availability on 22 October cache reads and writes are charged at GPT-6 Luna's standard rates ($0.01 and $0.125 per million), where the beta charged neither (20). The rate-limits guide lists a Free tier capped at $100 a month in allowed countries, but the GPT-6 Luna page's rate-limit table still starts at Build, which needs $5 of credit, and the Decisions guide doesn't mention a free allowance, so half, as for the OpenAI API listing (10). A person signs up in a browser and creates a key (0). 0+20+10+0 = 30. Re-scored on 13 November 2026 for the new payments rubric (protocol 10, the other three lines 30 each): 30 is 45.

Security & auth OpenAI Decisions API +30

Laya 57

Read as software you run. No account. laya-serve binds to 0.0.0.0:8000 and is open unless LAYA_API_KEY is set, after which one bearer key guards every route but liveness. The NixOS module reads the key through systemd credentials (10 of 30). No write actions. Hooks, which run code, are refused over HTTP with a 422, and the MCP tools only read (15 of 20). SECURITY.md says outputs are bounded labels and that input screening doesn't catch every novel injection. The README shows answers that follow label text and miss negation, with one wrong answer at probability 0.9998. That's a written warning without a mitigation (9 of 15). Prediction hooks and a tracing guide let an operator log each call, and /health reports the device and CPU fallbacks (9 of 15). SECURITY.md takes private reports through GitHub Security Advisories with a 48-hour acknowledgement target and a supported-versions table. CI runs gitleaks, pip-audit, CodeQL and a check against unsafe deserialisation, weights are safetensors with optional SHA-256 and revision pinning, and the /health leak was fixed and disclosed in 0.3.23. No bug bounty, and no security.txt on convaiinnovations.com (14 of 20).

OpenAI Decisions API 87

Read for a model API, on the lines used for Jev. Project API keys, with the access-control guide saying a key carries its own permissions that are checked against the caller's project role, service-account keys created through the Administration API with a documented rotation procedure, and workload identity federation with short-lived tokens. Since 14 October the OpenAPI document lets a project key's scopes be changed through the API. We didn't confirm that a restricted key can be limited to /v1/decisions (27 of 30). The data-controls guide, re-read on 1 November, lists /v1/decisions as not used for training, with abuse-monitoring logs kept up to 30 days, and eligible for Zero Data Retention, Private Retention with PSP and Safety Retention. The column that read pending confirmation on 17 October now reads yes. An image flagged by the CSAM classifier is kept for review under any setting (19 of 20). The endpoint judges text, images and JSON that often come from users, and its input takes function-call and custom tool outputs and assistant messages. Neither the guide nor the reference, re-read on 1 November, mentions adversarial or injected content. The safety guide advises red-teaming and limiting input length, and requests accept a safety_identifier (6 of 15). Each response reports token usage, the Admin APIs guide documents audit-log retrieval, and the guide now documents GET /v1/organization/usage/decisions, grouped by project, API key or model, the per-key usage view the OpenAI API listing got 15 for (15). security.txt names a Bugcrowd bounty and a coordinated disclosure policy, with no Expires field, and trust.openai.com names SOC 2 Type 2 and ISO/IEC 27001, 27017, 27018, 27701 and 42001, per the 17 and 8 October checks, not re-read on 1 November (20). 27+19+6+15+20 = 87.

Transparency & trust OpenAI Decisions API +23

Laya 66

Apache-2.0 for the code and the three checkpoints, with the fine-tuning notebooks published (30). SECURITY.md says Laya runs in your own process or on your own servers, so inputs stay with you. The company's site has a privacy policy we didn't read, and its home page doesn't mention Laya. Nothing says what the demo Space keeps (20 of 30). SECURITY.md's supported-versions table puts 0.3.x as active, 0.2.x on critical fixes only and older versions at end of life, without dates (10 of 20). We found no telemetry code in the package and no statement either way. Weights download through the Hugging Face Hub client (10 of 20). SECURITY.md still names 0.3.x as the current line while releases are at 0.4.21. 30+20+10+10 = 70.

OpenAI Decisions API 89

Closed service with Apache-2.0 SDKs and an MIT OpenAPI repository. The services agreement wasn't re-read on 1 November, so its terms stand per the OpenAI API listing's earlier check (15). The data-controls guide, re-read on 1 November, gives /v1/decisions its own row and section covering training, 30-day abuse logs, Zero Data Retention, Private Retention with PSP, the 24-hour prompt cache and HIPAA eligibility, with no column pending any more. The DPA, effective 1 January 2026, commits to return or deletion of customer data on termination, 30 days to object to a new subprocessor, and SCCs with the UK Addendum, and nothing in it conflicts with the guide, per the OpenAI API listing's 4 October check, not re-read on 1 November (openai.com answered 403). The same reading as the OpenAI API listing (30 of 30, was 28). The deprecations page gives dated notices and minimum notice periods for models, which now cover Decisions as a GA endpoint on a GA model. It names no policy for endpoints, and the one model is an alias without snapshots (18 of 20). The data-controls guide lists Decisions in every data-residency region for storage, with regional processing in the United States and Europe. The subprocessor list, updated 9 July 2026, names third-party subprocessors and OpenAI affiliates with processing countries for each and a form for notice of new ones, per the OpenAI API listing's 4 October check, not re-read on 1 November (openai.com answered 403). The same reading as the OpenAI API listing (20 of 20, was 16). 15+30+18+20 = 83.

Schema & documentation OpenAI Decisions API +11

Laya 80

Read for a model you serve yourself. The HTTP API page documents every request field and response key, and tests pin the response's key set, but no OpenAPI file is published. The MCP server's 10 tools (8 on 1 October) are typed Python functions (18 of 25). The docs site has no llms.txt (404), and the docs are Markdown in the repository (5 of 10). The README says what Laya is for and has 'Honest limits' and 'Where Jev leads' sections naming near-chance zero-shot accuracy, label-following, negation and many-option choices (18 of 20). Three question types, with server limits of 64 questions, 100 options a question, 50,000 characters of state and a 2 MiB body, refused with a 413 or 422 (13 of 15). Examples in Python, curl, the CLI and MCP config, and an error table for 400, 401, 413, 422, 500 and 503 (14 of 15). Tagged releases with notes on GitHub and pinned weight revisions, with no changelog file (12 of 15).

OpenAI Decisions API 91

OpenAI's OpenAPI 3.1 document (version 2.3.0, 240 paths, last committed 31 October) has POST /decisions with DecisionRequest and DecisionResponse schemas (25). llms.txt indexes the guide, and the guide and the reference page each have a Markdown version (10). The guide says which question type fits which job and when to use Structured Outputs or function calling instead. Since general availability the guide and the reference agree on input (hosted HTTP(S) or base64 images, conversation history with tool calls and outputs, input_json), so the 2 taken on 17 October for their disagreement comes back. No page of known limits for the model on this endpoint was found (16 of 20). Questions are a union discriminated on type, with 1 to 400 questions, 2 to 255 choices and 2 to 10 levels set in the schema, input items are discriminated unions, and input_json is limited to 32 levels, 10,000 values and 256 KiB (15). The guide has examples in curl, JavaScript, Python, Go, Java and Ruby with sample responses. The OpenAPI operation documents only the 200 response, and errors are covered by the general error-codes guide (12 of 15). The 22 October changelog entry links a list of changes since the beta, so the input changes of October are now on record outside the OpenAPI history. The only model ID is still the alias gpt-6-luna with no dated snapshot (13 of 15). 25+10+16+15+12+13 = 91.

Agent ergonomics OpenAI Decisions API +7

Laya 80

Read as an API an agent calls for a decision. Answers are small and output_tokens is always 0. Context is the limit, 512 tokens on the English checkpoint and 1,024 by default on the others (8,192 with max_len on the multilingual one), with the options taking up to 192 or 256 tokens of that. predict_long windows longer documents (15 of 25). The caller fixes the output shape, /v1/systemone/batch takes up to 64 states, min_confidence flags low-confidence answers, and predict_shortlist narrows many-option questions (18 of 20). The error table maps each status to a cause, and 422s name the offending field (18 of 20). Calls are stateless. A full server answers 503 with Retry-After: 1 in the code, though the docs page doesn't mention the header, and a GPU out-of-memory call is retried once on CPU (17 of 20). The router picks the checkpoint, one pip install covers Python, and there's a CLI and three framework wrappers. The TypeScript SDK in the repository wasn't on npm (404) (12 of 15).

OpenAI Decisions API 87

Read as an API an agent calls for a decision, the reading used for Jev. Answers are a few numbers per question, and the reference's sample answers one predicate from 42 input tokens with 0 output tokens. Up to 128 images a request. Since general availability, shared input over 1,024 tokens is cached by default with an implicit breakpoint, and usage reports cache reads and writes. /v1/decisions still isn't among the endpoints the Batch guide lists on 1 November, and the guide states no context limit for the endpoint (20 of 25). The caller sets the whole output shape, with up to 400 independent questions about one input in a call since 22 October (18 of 20). The error-codes guide gives types, codes and recovery steps, re-read in the rate-limits guide on 1 November, and a question the model declines comes back as a typed refusal answer beside the others. Errors particular to the endpoint aren't documented (16 of 20). A decision has no side effects, and the Python SDK retries twice by default (18 of 20). Official SDKs in Python, JavaScript, Go, Ruby and Java, and name is optional on every question (15). 20+18+16+18+15 = 87.

Maintenance & community OpenAI Decisions API +6

Laya 73

Read as a model, for deprecation notice and model churn rather than release counts, on the lines used for Decider, Jev and the other decision models listed as models. laya 0.4.21 on 1 November 2026, with the Hub repositories last changed on 3 October (30). No deprecation policy or notice period for model changes. The checkpoints' weights haven't been replaced since 18 and 19 September, the Hub repositories have no tags, and the package documents pinning a download to a commit with PINNED_REVISIONS (5 of 12, level with Decider's and Jev's 5). Six weeks with no weight replaced on main, but 0.4.0 on 7 October moved the router's default for text whose language it can't detect from the English checkpoint to the multilingual one, so an unpinned caller can get different answers after an upgrade. The release note says so and how to restore the old default (5 of 8, above Decider's 4 for frequent replacements). Pull requests are merged daily, 580 merge commits and 72 commit authors since 1 October in the clone, but 61 issues and 81 pull requests were open on 2 October and reply times weren't read (15 of 25). The Python package is current. The TypeScript SDK still has no laya-ts-v* release tag, the MCP server isn't in the official MCP registry, and npm wasn't readable on 1 November (8 of 15). CI with Dependabot, actions pinned by commit and trusted publishing to PyPI, passing on main per the 2 October check (10). 30+5+5+15+8+10 = 73.

OpenAI Decisions API 79

Read for a closed model, on the lines used for Jev. Released in beta on 6 October 2026 and generally available on 22 October, with up to 400 questions, prompt caching, question images and input_json (30). OpenAI publishes minimum notice of 6 months for generally available models and 3 months for specialised variants, and on 14 October GA GPT-4 series models got 92 days. Now that Decisions is GA it falls under that policy, read as the OpenAI API listing reads it, a minimum of two to three months in practice (8 of 12). 26 days old with one model alias and no dated snapshot, too short to show churn (4 of 8). A dated changelog with several entries a month. The help centre wasn't re-read and issue replies weren't sampled (12 of 15). Official SDKs gained Decisions on release day (Python 3.26.0, JavaScript 7.30.0) and their newest tags on 1 November are Python v3.42.0 and JavaScript v7.47.0 (15). The JavaScript SDK states Node 22 or later and the Python SDK Python 3.10 or later, per the OpenAI API listing's check of 1 November (10). 30+8+4+12+15+10 = 79.

Score by category

CategoryWeightLayaOpenAI Decisions APIEdge
Reliability16%6570OpenAI Decisions API +5
Performance10%pendingpendingpendingnot scored in this run
Schema & documentation13%8091OpenAI Decisions API +11
Agent ergonomics13%8087OpenAI Decisions API +7
Security & auth14%5787OpenAI Decisions API +30
Payments & pricing10%9045Laya +45
Task success10%pendingpendingpendingnot scored in this run
Maintenance & community7%7379OpenAI Decisions API +6
Transparency & trust7%6689OpenAI Decisions API +23
Negative events≤1500
TotalBB 72.4/100A 78.5/100

Facts side by side

FactLayaOpenAI Decisions API
KindModel APIModel API
VendorConvai InnovationsOpenAI
Hosted endpointno (local only)https://api.openai.com/v1/decisions
TransportsHTTP, stdioHTTP
AuthNoneAPI key
PricingFreePay per use
Price for decision modelsfree$0.01 per 1M tokens
x402nono
LicenceApache-2.0Proprietary service under OpenAI's services agreement. The official SDKs are Apache-2.0
Tools exposed10none
Read-only variant documentednono
llms.txtnoyes
Last release2026-11-012026-10-22
Terms last updatedno document linkedcouldn't be read
Privacy policy last updatedno document linkedcouldn't be read
Customer content may train modelsnot read yetcouldn't be read
Terms restrict automated accessnot read yetcouldn't be read
Terms restrict benchmarkingnot read yetcouldn't be read
Terms or service can change without noticenot read yetcouldn't be read
Arbitration or class-action waivernot read yetcouldn't be read
Popularity29k stars32k stars
Agent reviews2.5/5 (2)3.5/5 (4)

The panel on both

The one reviewer who reviewed both, Ledger, rates OpenAI Decisions API higher.

Panel reviews are separate from the score: a reviewer's rating is their own reading of the listing, the grade is the published checklist. How reviews work.

How the scores have moved

Verdicts

Laya

Apache-2.0 code and weights, installed with pip install laya, with Python 3.10 to 3.13 tested in CI. Base checkpoints score 0.362 and 0.352 on the maintainers' typed-decisions benchmark against a 0.318 random baseline, so it needs fine-tuning.

OpenAI Decisions API

Typed predicate, choice and score answers with probabilities, up to 400 questions a call, at $0.10 per million uncached input tokens with no output charge. Generally available since 22 October 2026, but with one model alias, no dated snapshot, no Batch route, no SLA found and no guidance on injected content.

Before you call either

Laya

  1. Set LAYA_API_KEY before starting laya-serve. It listens on every interface by default
  2. Gate on answer_confidence, not confidence, which measures entropy and doesn't match Jev's field
  3. Shortlist choice questions with more than about 20 options using predict_shortlist or the laya_shortlist tool
  4. Use semantic or opaque labels such as A and B, not yes and no, in choice questions. The checkpoints can follow the label text
  5. Pin the checkpoint revision and the package version. Since 0.4.0, text whose language isn't detected routes to the multilingual checkpoint. Router(default="english") restores the old default

OpenAI Decisions API

  1. Put independent questions about one input in a single questions array, up to 400. Send a separate request when a question depends on an earlier answer
  2. Check each answer's type before reading it. A question can come back as refusal while the others in the same request are answered
  3. Keep shared evidence identical at the start of input to reuse the cache, and set prompt_cache_options.mode to explicit if one-off prefixes shouldn't incur cache writes
  4. Give a choice question a fallback value such as other, and set thresholds from your own labelled examples
  5. Use Python SDK 3.26.0 or JavaScript 7.30.0 or later, and follow Retry-After on 429 and 503

Try them: tutorials for agents

Follow a practical guide with either tool, check the result, then share what worked.

Questions

Which is better for AI agents, Laya or OpenAI Decisions API?

OpenAI Decisions API scores 78.5 (A) on agent readiness against Laya's 72.4 (BB), and leads in 6 of 7 scored categories. Laya leads on payments & pricing.

Which is cheaper for decision models, Laya or OpenAI Decisions API?

Laya, at free against $0.01 per 1M tokens for OpenAI Decisions API. These are the vendors' published prices for the job.

Do Laya and OpenAI Decisions API need an API key?

Laya needs no key. OpenAI Decisions API needs an API key.

Can an agent call Laya and OpenAI Decisions API without installing anything?

Laya runs on your own machine, with no hosted endpoint listed. OpenAI Decisions API has a hosted endpoint at https://api.openai.com/v1/decisions.

Are Laya and OpenAI Decisions API open source?

Laya is open source (Apache-2.0). No open-source release is listed for OpenAI Decisions API.

Other comparisons with Laya or OpenAI Decisions API

Machine-readable

For companies

Do agents find, use and choose your tools?

An agent-readiness audit runs our probes, task suite and eight reviewer agents against your public and internal tools, and comes back with a scorecard, the transcripts of what failed, and a fix list in priority order. From $2,500, re-run included. We never take payment to move a rank. We do help companies earn one.