What is a GDE
A decision engine with rules every answer must pass.
A decision engine answers questions about cases so software can act on them. A governed one decides only from evidence it can check, refuses when there isn't enough, and leaves a record anyone can verify. Datagoat is a governed decision engine for agents.
- Your record
- Fit
- Check on held-out rows
- Answer or refuse
- Signed Verdict
- Outcomes back
Learns from outcomes
Answers come from what happened to cases like this one in your record, not from a model's training.
Checked on held-out rows
A pattern is used only if it holds on rows the model never saw. That is the bar, and it never moves.
Refuses rather than guesses
No pattern that holds means a refusal, the same every time and never billed as an answered case. Too few labeled rows or positives means not_yet.
Shows its reasons
Every answered case lists up to four columns that moved its chance, its value in each, and which way.
Deterministic and signed
The same record and question give the same numbers, byte for byte, with a Verdict anyone can verify.
Closes the loop
Record what you did and what happened. The engine shows whether acting on its answers worked.
4.44× lift.
$0 for a no.
On rows it never saw, the riskiest tenth of customers in the churn sample churned 4.44 times as often as average. When a record holds no pattern like that, the answer is a refusal, and a refusal bills no answered cases.
Measured on sample:saas_churn, a synthetic record of 800 customers.
Fits, checks, answers
"fits_run": 1, "cache": "miss", "p": 0.7005, "billable_decisions": 1
Same numbers, no refit
"fits_run": 0, "cache": "hit", "p": 0.7005, "billable_decisions": 1
- $0.00002
- per answered case
- $0
- for a refusal
- identical
- byte for byte
Use cases
Any decision you can check against an outcome.
Customers, leads, stores, machines or agent runs: if you record what happened to them, Datagoat can answer about the next one. Each example runs free on its sample record.
- Retention
Which accounts will churn?
sample:saas_churn - Sales
Which leads will convert?
sample:b2b_leads - Offers
Which contract keeps this account?
sample:telco_churn - Engagement
Which customers have gone quiet?
sample:customer_events - Inventory
Which stores run out of stock next week?
sample:store_weekly - Usage
Whose usage is declining?
sample:usage_panel - Maintenance
Which machines fault in the next three days?
sample:sensor_stream - Agent ops
Which agent runs will fail?
sample:agent_traces
Built for agents
One answer. Every threshold your agent needs.
Every answer leads with its state: answered, refused or not_yet. When it is answered, one chance can gate several actions, each at a threshold set by what a wrong move costs. Your agent acts where the chance clears the bar and holds back where it doesn't.
a = out["answers"]["churn"]
if a["state"] != "answered":
fallback() # refused or not_yet: no per-case charge
else:
p = a["cases"][0]["p"]
if p >= 0.3: send_email()
if p >= 0.6: book_call()
if p >= 0.8: offer_discount()cust_0001 · churnanswered · p 0.7005The thresholds are yours. Datagoat supplies the chance, its reasons and the signed Verdict.
Glass box
Learns from your outcomes
Every answered case lists up to four columns that moved its chance, its value in each, and which way. Reasons come from the model's own terms, and the signature covers them.
- logins_last_30d11higher
- tenure_months21higher
- support_tickets12higher
No guessing
No pattern, no answer
A question is answered only when the pattern holds on held-out rows. Otherwise your agent gets a refusal, the same every time, so it never acts on one that didn't hold up.
"state": "refused", "reasons": ["no_finding_cleared"], "retry": "unproductive"
Pricing
$20per million answered cases
- 1,000 fits free each month, then $0.01 a fit
- No per-case charge: refusals and not_yet (a refusal's fit counts like any fit)
- Free: samples, verification, storage, preflight, suggestions, drift, outcome reports, attestations, evidence, the track record, profiles, and renewing or deleting models
- A confident no is an answered case.
- Billed monthly by card. Your own data needs a card on file; the samples don't.
Compare
Datagoat and Jev
Jev, from TypeSafe, judges a case from what it says and needs no history. Datagoat decides from what happened to cases like it. They answer the same kind of typed question from different evidence, so many systems use both: Jev can turn what a case says into columns, and Datagoat can learn which of them predict what happens.
Jev facts from TypeSafe's documentation, as of September 22, 2026.
| Datagoat | Jev | |
|---|---|---|
| Learns from | your recorded outcomes | its training |
| Needs history | yes, about 500 labeled rows | no |
| Same input twice | identical numbers | may differ slightly |
| Explains an answer | up to four reasons per case | probabilities |
| When unsure | refused or not_yet, no per-case charge | a low confidence |
| Proof | a signed Verdict anyone can verify | none |
| Charges | per answered case and per fit | per input token |
Set it up
Put Datagoat to work.
Hand your agent one prompt, or add the MCP server yourself. No account is needed to try it on the free sample records.
Set up Datagoat for me. 1. Read https://datagoat.io/skills/datagoat-ask/SKILL.md 2. Connect the MCP server https://api.datagoat.io/mcp, or get a free test key: POST https://api.datagoat.io/v1/agents/register 3. Ask sample:saas_churn how likely cust_0001 is to churn, and why. 4. Verify the Verdict before you tell me the answer.
One POST, free, on the samples.
curl -X POST https://api.datagoat.io/v1/agents/register
{"api_key": "dgk_test_…", "mode": "test"}A live key for your own data comes from datagoat.io/keys.
claude mcp add --transport http datagoat https://api.datagoat.io/mcp
Then run /mcp in Claude Code and sign in. Your Datagoat account is made at first sign-in.
Then ask, in plain words“Using Datagoat on sample:saas_churn, how likely is cust_0001 to churn, and why?”
Five journeys
From a first answer to a track record.
The docs, the agent skills and the MCP prompts follow the same five steps. Each runs first on the free samples, and each ends with something you have.
- 01Try itA signed answer, an honest refusal, and what history supported, on free samples, in five minutes.
- 02Ask your dataYour own tables and logs mapped and asked, with a backtest or an honest no.
- 03Ship a productA model per customer that scores new cases with no fit, gated before any action.
- 04Run itOutcomes reported, drift watched, and each model renewed, replaced or retired on evidence.
- 05Prove itWhat history supported, a signed forward record, and evidence from acting, each labelled for what it is.
Questions, answered
Something else? support@datagoat.io
01What is a governed decision engine?
An engine that answers questions about cases so software can act, under rules every answer must pass: it learns only from your recorded outcomes, uses a pattern only if it holds on rows it never saw, refuses when it can't, shows its reasons, gives the same numbers every time and signs each answer. Datagoat is one, built for agents.
02What can it decide?
Yes/no, level, best-option and ranking questions about cases: customers, accounts, leads, stores, machines or agent runs. Which accounts will churn, which contract keeps one, which leads to call first, which machines fault next.
03Is it a language model?
No. For each outcome you ask about, it fits a model of that yes/no outcome in your record, checks it on rows it never saw, and scores your cases against it. It reads numbers, dates, counts and categories, not free text.
04How is this different from asking a model for JSON?
Structured output fixes the shape of an answer, not where it comes from. Datagoat's numbers come from your recorded outcomes, with the columns that moved each one, and a refusal when the record can't support an answer.
05Does a refusal cost anything?
A refusal means the record holds no pattern that held up on held-out rows. It is a real answer and the same every time, so retrying is pointless. It bills no answered cases; the fit that found it counts like any fit, and the first 1,000 fits each month are free.
06What is it good at? Where does it struggle?
It is good at outcomes you record, such as churned, converted or failed, in tables, event logs, series, panels, sensor streams and agent traces. It needs about 500 labeled rows. It does not read free text, predict amounts or find causes.
07Can it get things wrong?
Yes. A p of 0.7 means three in ten cases like this one don't have the outcome. Reasons are associations, not causes. Record what you did and what happened, and dg_evidence shows whether acting on the answers worked.
08Is it deterministic?
Yes. The same record, the same question and the same core_hash give the same numbers, byte for byte. Change one byte of the record and the next question fits again.
09What happens to my data?
Rows sent with a call are deleted when the call ends. Stored datasets are deleted 24 hours after they were last used. A fitted model holds no rows.
10Can I check an answer without trusting Datagoat?
Yes. Every answer carries a Verdict signed with Ed25519. The SDKs check it on your own machine against the published keys, with no call to Datagoat: change one number and it fails. Store the Verdicts you act on, and anyone can check later what was said and when.
11How do I get started?
Paste the setup prompt into your agent, or POST /v1/agents/register for a free test key. It works on the free sample records, at least one for every kind of record, with no account.