The professional API: build the model, and own it
The public engine runs a model you already hold — one decision, one flat rate, self-serve. The professional tier is the other half: it builds and composes the models themselves. You bring the pieces or the data; you get back a single model you own outright, with a certificate you can re-check yourself. This page is what that tier is, what it does, and what it costs.
What you are buying, named plainly: a Hilbert space built over the concepts your business actually uses, and the Hamiltonian that says what it settles toward. The public space is open to every account on the platform; the one built for you is a private partition you own, fenced from every other customer. Billing for this tier is by invoice through Agile Integrations LLC.
And what it is, in one line: one operator that answers four questions — what to do, what you already know that is closest to this, what you are holding, and what has changed. A decision is the first of the four, not the whole thing. Two services stand behind them: one holds your model, one settles it. A certified answer carries the math that checks it, and every call is audited (an append-only record) and metered on the work it does — never per seat.
Request a quote Start a conversation Every product, with its door and price
Run by the people who build it
This is not a black box handed to you cold: it is the same door the people behind Agile Integrations run on their own engagements, metered the same way you would meter it. The base rate for running a model is the one already published at embark.day/pricing — $0.02 per 1,000 tokens, unchanged here. What this page prices is building a model, not running one.
Two ways to use the engine: RUN and BUILD
It is one engine, used two ways, and the line between them is the whole product. This is the mental model worth carrying into the rest of this page.
RUN — public, prepaid
You run a model you already hold and get an answer back: bounded, verifiable, and cheap enough to serve to anyone. One flat rate, no tiers, no qualification, self-serve. That is the public rate card at embark.day/pricing, and it does not change.
BUILD — professional, invoiced
You build, combine or refine a model — your asset. It consumes real compute and leaves you holding something durable you then own, so it is metered by the compute it uses, billed by invoice, and qualified first. That tier is this page.
The line is deliberate. Running a model is a commodity and we price it like one. Building one is the work, the cost, and the thing worth owning — so we license you the engine that builds it, and you keep what comes out.
What the professional tier lets you build
One door — POST /v1/hilbert, qualified and metered — reaches the
build operations. Each one takes models your own account already holds and returns a new model you own,
with a certificate. (If a single bounded decision is all you need, the raw solver is
POST /v1/optimize.)
Build a layered model · build_nested_hamiltonian
Turn several smaller models into one denser model that answers the whole problem at once — split into exactly-solvable pieces, each solved, then recomposed into a layered model you own.
Combine two models · couple
Join two of your own models across a boundary you define, where only a defined boundary summary passes between them — never their raw data.
Settle to the answer · settle_ladder
Run a model down to its final, best-fit state, with every step booked to your ledger so the result is auditable line by line.
Import a trained model · encode
Read a layer of a model you already trained into a bounded model on our engine — the bridge from what you already have to what the engine builds on.
Align and compose · compose
Rotate several of your own models into one shared frame and compose them into a single model, with a per-input alignment score you can inspect.
Standing reads & loops · standing_read · run_loop
A standing query that re-answers itself as your model changes, and a control loop that drives a model you own toward a target you set.
Answer & argue over your own material · consult ·
dialectic
Ask a question and get an answer cited to the passages you submitted, or argue a claim and get back what defends it and what attacks it — both read only the material you send or have filed with your account, never ours.
Run your own series forward · evolve_pde
Evolve your own measured readings under the error, time and spend bounds you set — the door certifies which bound stopped the run, and only the steps that actually ran are billed.
Search a model you own · qaoa
A variational search over a model you hold, reporting how far its answer landed from the proven best — a measured distance, not a claim of the fastest route there.
Read the pole, the confidence and the halo of a pair you own · halo
See a choice the way the Bloch sphere draws it: the pole it decides to, how sure it is, and the ring its correlations live on, as numbers your app can draw. On a model you own the ring is the model's reading of that confidence, and the answer says so; counts you recorded from a pair add intervals and a reading against the classical bound.
Review someone else’s system · assurance_review
Check the documents a supplier hands over against the clauses you name: one finding per clause, each resting on a passage you can re-open or refused by name. It is the call behind our third-party review, whose accuracy is not yet measured.
Presented in what they do, not how — the interface and the value, which is all a buyer needs to decide. The machinery underneath is the part we license rather than publish.
Hilbert as a service: HOPE, the memory
HOPE is the memory this tier sells: a Hilbert space your account owns, filled
with your own readings, that answers by settling rather than by searching. It runs on the door everything on
this page runs on, POST /v1/hilbert, qualified and metered, and it is quoted and invoiced like the
rest of the tier.
Create a space · encode · build_text
Read a layer of a model you trained, or a body of your own text, into a space your account owns and no other account can reach.
Recall by settling · recall
A probe in your space’s own frame is settled against the readings the space holds, through a Hopfield recall, and the state it comes to rest in is the item retrieved: retrieval by settling, not a nearest-distance lookup.
Read it and reason over it · halo · settle_ladder
The halo read gives a choice’s pole, confidence and ring, and the settle ladder takes the space to
rest with every step booked. consult and dialectic answer and argue over the
material you filed, and compose aligns several of your spaces into one.
The library. We committed 99 model spaces, each read from an open text, vision or audio model. Recall was measured on its 21 text spaces, and a third-party review reads a system’s stated model against it.
What is measured. Across 840 held-out readings of those 21 spaces, recall at the shipped setting named the right space first 372 times (44%) and within its first three 541 times (64%). Chance would name it first about 5% of the time.
Ask Day is measured on this same memory. Our own 2,026 published
passages, read into a 32-direction space by the same encode engine you rent, recall a
held-out passage’s page first time 49% of the time and within the top five 65%
when asked with the passage’s own reading, which is how we test it, and first time 15% of the time and within the top five 26%
when asked in words, the way a visitor asks.
What it does not claim: a recall rate on your own material before we have measured one there, or a space of any size, since recall over a space past the door’s exact limit is refused by name unless you ask for the approximate path. The free question box on this site does not use HOPE; it reads our published pages.
What it costs
The professional tier is compute-metered — you pay for the compute a build actually uses — and invoiced, prepaid. The figures below are indicative drafts: the real number for your work comes back with a quote, not off a web page. The public RUN rate ($0.02 per 1,000 tokens) is the already-live rate and is not one of these.
| Build operation | Metered by | Indicative draft |
|---|---|---|
| Import a trained model | per model layer | ~$0.02 / layer |
| Settle to the answer | per settle step | ~$0.10 / step |
| Align and compose | per model aligned | ~$0.25 / model |
| Build a layered model | per build step × depth | ~$0.25 / step (a four-layer build ≈ $1) |
| Combine two models | per combined model | ~$0.50 |
| Standing read | per read | token-metered, at the public rate |
| Control loop | per iteration | self-metered per run |
Answer a question over your own material · consult | per answer | ~$0.05 |
Argue a claim over your own material · dialectic | per argument | ~$0.05 |
Run your own series forward · evolve_pde | per step evolved | ~$0.05 / step |
Search a model you own · qaoa | per layer run | ~$0.05 / layer |
Read the pole, the confidence and the halo · halo | per reading | ~$0.05 |
Build a model from your own samples, or complete one · pattern_memory | per call, on the compute it uses | from $0.50 |
Bring your own objective · the raw solver, POST /v1/optimize | per compute-second, on the objective's own size | billed to actual compute — no per-call draft; quoted at signup |
| Build a new model from data | per compute-hour | quote — the flagship |
| Enterprise | volume + support | invoice, no public price |
Bring your own objective. One call takes up to 570 terms, the largest objective we measured finishing inside the 30-second limit; a larger one is refused before any charge, and a call that runs past the limit is stopped and not billed.
Every professional figure here is a draft pending pricing decisions. There is no self-serve purchase for this tier: a business account is set up after a conversation, invoice-billed and prepaid, all sales final. See how a business account works on how we work.
The consultant's own time is billed separately from the answer. When a
consult call names an ongoing engagement, the time Day spends on it is booked as its own
line, distinct from the per-answer fee above: engagement time is billed per second at a rate quoted on
your invoice, never a number we publish here.
Refused before you are charged
A key that is not qualified for the professional tier is turned away before any money moves: the door returns a refusal, not a bill. Qualification is required, and a key can only ever build or compose its own models — never another account's. It is a guarantee in both directions: you cannot be charged for a build you were not entitled to run, and no one else's key can touch what you own. A sensor network over more than 16 candidate sites is a professional engagement, quoted and invoiced. A standard key is refused before anything runs and is never charged.
How access works, and what keeps your model yours
Four places an account can stand, each a different door with a different check that runs before anything else: the public library (our published material and the open model library — no space of yours is reachable from it), your account (run what you hold, prepaid, at the flat rate), professional (this page: build and compose, on a key graded for it), and operator (our own console and the engine that builds our own models — not sold, and not reachable from a customer key at any tier).
- Your account is your namespace, exactly. The mapping is total and one-to-one, so two accounts can never collide and a near-miss resolves to nothing rather than to somebody else's model. Reads and writes are scoped to it in both directions.
- Only a defined boundary summary crosses a boundary. When two of your models are combined, what passes between them is that summary — never their raw state.
- The public surface is a list of what is allowed. Anything not on it answers 404, so a capability cannot ship accidentally exposed, and one redactor runs on every response.
- Fail-closed, auditable, billed once. Missing credentials refuse; unavailable storage returns a retry, never a misleading “bad key”; privileged actions land in an append-only record whose entries each carry the previous entry's hash; a retry with the same request id books a single charge and a refusal books none.
What makes it an enterprise product, honestly
- You own what you build. The model you build is yours, delivered under Apache 2.0 with its certificates. The offline runtime that re-runs it is written and tested but not yet published for installation — we will link it when there is something to link, and until then an exported model plus free offline re-verification is what ships. The engine that builds a model is the part we license, and that line is the whole business.
- A certified answer is checkable offline. It carries a certificate you re-verify on your own hardware, and re-verifying is free at every tier — gating the proof would defeat the point of having one.
- Computed, not guessed. These are computed answers: a computed model returns a computed value; nothing in it is generated. There is no metered charge for re-running an exported model offline, and no data leaves your boundary to produce them.
- The floor is real, and the rest is dated. An append-only audit log and idempotent billing (you are never double-charged for the same request) are done today. Single sign-on and directory sync, data export and erase, service-level targets and paging, and data-residency options are on the roadmap — named here rather than implied, so you can hold us to the list.
Request a quote Start a conversation How the optimisation line is sold