AI you can
program,
not just
prompt.

  • JSON
  • Schemas
  • Policies
Request access

How it works

“I've been charged twice.”

One message to customer support. A decision tree of possible next steps.

Blatent Struct brings programmability to language models. You define the decisions AI can make, the conditions for each branch, and what each must return—all within strictly enforced constraints.

JSON Schema defines the branches and their outputs. Context informs the decision. Policies enforce what's allowed.

Meet Struct
One decision · two possible branches

Define what each decision needs

Define the choices in JSON Schema. A refund requires a transaction ID and amount. An escalation requires a reason and team. Each result follows one branch, with the fields that branch needs.

Resolution

actionRefund
requirestransaction_idamount_cents
actionEscalate
requiresreasonteam
View JSON Schema
json
{
  "type": "object",
  "properties": {
    "department": { "const": "billing" },
    "resolution": {
      "oneOf": [
        {
          "type": "object",
          "properties": {
            "action": { "const": "refund" },
            "transaction_id": { "type": "string" },
            "amount_cents": {
              "type": "integer", "minimum": 1
            }
          },
          "required": [
            "action", "transaction_id", "amount_cents"
          ],
          "additionalProperties": false
        },
        {
          "type": "object",
          "properties": {
            "action": { "const": "escalate" },
            "reason": { "type": "string" },
            "team": { "enum": ["payments", "disputes"] }
          },
          "required": ["action", "reason", "team"],
          "additionalProperties": false
        }
      ]
    }
  },
  "required": ["department", "resolution"],
  "additionalProperties": false
}
State and request context

Use context to choose the next step

Your application supplies transaction details, the agent’s permissions and the bank’s refund limit. Here, the state confirms a duplicate charge, but the agent has no refund-approval permission. Your policy rules out a refund, so Struct returns an escalation to the payments team.

Application contexttxn_1042

Duplicate chargeConfirmed

Charge amount£25

Refund limit£50

Agent can approve refundsNo permission

View request context
json
{
  "state": {
    "transaction_id": "txn_1042",
    "charge_cents": 2500,
    "duplicate_confirmed": true
  },
  "user_context": {
    "scopes": []
  },
  "parameters": {
    "refund_limit_cents": 5000
  }
}
Policy enforcement

Enforce the rules before returning

An OPA policy checks the proposed refund against the agent’s permissions, the transaction and the bank’s refund limit. Struct only returns a result that satisfies your schema and policies.

Proposed refund£25 · txn_1042

Duplicate charge confirmedPass

Transaction matchesPass

Amount within charge and limitPass

Agent has refund permissionFail

Refund unavailableEscalate to payments

View OPA policy
rego
package banking
import rego.v1

default allow := false

allow if {
  refund := input.output.resolution
  refund.action == "refund"
  input.state.duplicate_confirmed == true
  "refunds:approve" in input.user_context.scopes
  refund.transaction_id == input.state.transaction_id
  refund.amount_cents <= input.state.charge_cents
  refund.amount_cents <= input.parameters.refund_limit_cents
}

allow if {
  escalation := input.output.resolution
  escalation.action == "escalate"
  escalation.team == "payments"
}

Dependent decisions. One run.

Every decision narrows the next.

A complex workflow can have thousands of possible paths. Struct uses what your application already knows to eliminate impossible choices, then lets each decision narrow what comes next. No need to work through the entire tree.

Explore the schema guide

“I’ve been charged twice.”

Duplicate charge confirmed, refund approval required.

billingescalatepayments

  • Selected path
  • Ruled out by context
  • Other branches

ACROSS 20 BENCHMARKS

Blazingly fast.
Blatantly obvious.

Blatent Struct

145 milliseconds

Fast responses across classification, fact checking and question answering.

OTHER MODELS

  1. Jev 1.13.0

    317ms

  2. GPT-6 Sol

    1,403ms

  3. Claude Sonnet 5.5

    1,565ms

  4. Gemini 3.8 Flash

    3,255ms

Average p50 across 20 benchmarks, with each dataset weighted equally.

View
↑ More accurateBlatent StructOther modelsPareto frontier
← FasterMean p50 latency · log scale

Do you really need more proof? Fair. Let’s go straight to the source.

EXTRACTION, WITHOUT INVENTION

Find the answer.
Keep the original words.

Give Struct a question and some source text. It selects the answer directly from that text, preserving the original wording.

Which Block I CSM was not launched in August?

Source
Two Block I CSMs were launched from LC-34 on suborbital flights in 1966 with the Saturn IB. The first, AS-201 launched on February 26…
01 From the source

Blatent Struct output

“AS-201”

Original wording guaranteed

02 Lower cost

62%

$0.049 Struct vs $0.130 Clairic

Lower estimated cost. Per 1,000 requests.

03 A shorter long wait

36%

281 ms Struct vs 438 ms Clairic

Lower mean dataset p95 latency.

04 More accurate

+5.85pp

87.51% Struct vs 81.66% Clairic

Mean accuracy across six benchmarks.

THE WIDER PICTURE

And against the usual suspects?

Six benchmarks.
Every dataset gets an equal vote.

Datasets: AdversarialQA, BioASQ, Natural Questions, NewsQA, QASPER, TyDiQA-GoldP.

Exact-match scoring can reject valid answers with different span boundaries. We used GPT-6 Astra to judge answer correctness against the source.

ModelCost USD / 1,000 requests ↓Speed Mean dataset p50 / p95 ↓Accuracy Astra-judged mean ↑
Blatent StructOriginal wording guaranteedCost / 1k$0.049Speed230 ms281 ms p95Accuracy87.51%
Cloudflare ClairicOriginal wording guaranteedCost / 1k$0.130Speed193 ms438 ms p95Accuracy81.66%
GPT-6 LunaCost / 1k$0.152Speed1,254 ms3,689 ms p95Accuracy87.48%
Claude Haiku 5.5Cost / 1k$0.218Speed1,113 ms1,776 ms p95Accuracy83.29%
Gemini 3.5 Flash LiteCost / 1k$0.388Speed553 ms732 ms p95Accuracy80.91%
Gemini 3.8 FlashCost / 1k$1.157Speed2,006 ms4,572 ms p95Accuracy73.76%
GPT-5.6 TerraCost / 1k$3.079Speed1,128 ms1,522 ms p95Accuracy91.61%
Claude Sonnet 5.5Cost / 1k$4.393Speed1,169 ms2,005 ms p95Accuracy89.44%

Pricing

Have we mentioned
we’re cheap?

$0.042

per million input tokens · USD

That’s the base rate for up to 20 decisions per request. Above 20, the rate scales with the decision count: 40 decisions cost 2×; 100 cost 5×.

Cost calculator

Do the (very small) maths.

Roughly ¾ of a word per token.

Up to 20 at the base rate. 40 = 2×, 100 = 5×.

Estimated price per request

1× multiplier

$0.000042

1x decision multiplier, one million requests: $42.00

$0.042 ÷ 1M × tokens × max(1, 0.05 × decisions)

What counts as a decision?

A number, a boolean or an enum selection counts as one decision. Strings count as one decision per 20 characters.

Fast, strict and structured.
More adjectives on the way.

GET STARTED

Request access

Sign up to try the Struct API. We’ll email you when your access is ready.

Company size

By continuing, you agree to our Terms and Conditions and our Privacy Policy.