For developers using coding agents

Fast models for decisions your software makes again and again.

Sparkient trains a small model for each repeated decision your application needs to make.

Your coding agent can find repeated rules and live LLM calls in your codebase. You can test the strongest candidate before changing your application.

Latency depends on what runs

usually <1ms
RulesDeterministic constraints and lookups
varies
Custom MLDepends on the model, features, hardware, and serving
33–42ms
SparkientBatch-average time per item in four synthetic runs; not per-request p95
varies
Hosted LLM APIsDepends on the model, prompt, provider, network, and retries
91–96%
Accuracy in synthetic benchmarks
33–42ms
Batch-average time per item
4
Published synthetic benchmarks

Check your codebase

Ask your coding agent whether Sparkient fits

Paste this prompt into the coding agent you already use. It will look for repeated rules and live LLM calls, then explain whether Sparkient would help.

Copy this prompt

Research Sparkient online (start with https://sparkient.ai/llms.txt), inspect this project, and tell me whether Sparkient would be useful.

The prompt sends your agent to Sparkient's current product, pricing, and evaluation guidance before it reviews the code.

Good fit

  • The same decision is made many times, with a fixed set of answers
  • The answer depends on wording, behaviour, or context
  • Calling an LLM every time is too slow or expensive

Not a good fit

  • Ordinary code already handles it reliably
  • The output is open-ended, such as prose, images, or code
  • You cannot define a stable answer and measure whether it is correct

How It Works

Build and test a model in three steps

1

Define

Set the possible answers, input fields, and any rules that must always apply.

2

Build

Add labelled examples, or let Sparkient create a starting set. Sparkient trains and tests the model.

3

Run

Call the model through the API. Growth and Scale plans can export a model to run locally. The cloud version can ask an LLM when it is unsure.

Request
curl -X POST https://api.sparkient.ai/api/v1/decide \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "decision_type": "content_moderation",
    "input": {
      "text": "Check out this amazing product!",
      "user_trust_score": 0.82
    }
  }'
Illustrative response
{
  "decision": "approve",
  "confidence": 0.94,
  "reason_codes": ["CONTENT_SAFE", "TRUSTED_USER"],
  "escalate": false
}

Test the model on your own examples before using it in production.

Comparison

Compare a hosted LLM API with Sparkient

Sparkient runs a task-specific model. The cloud path can ask an LLM when the model is unsure.

Hosted LLM API
Sparkient
What runs?
A live provider model
A task-specific model
Latency
Depends on the model, prompt, and provider
33–42ms batch-average time per item in four synthetic runs
Billing
Provider usage on every call
Operations use monthly plan credits
Customisation
Prompted for the task
Trained on your policy and examples
Offline use
Provider connection required
Edge bundle on eligible plans

Benchmarks

Results from four synthetic benchmarks

Each benchmark used 5,000 examples created and labelled by an LLM. The timing runner divided one batch duration by its item count; it did not measure per-request p95. These models have not yet been tested on customer data.

Support Ticket Triage

5 outcomes · 5,000 synthetic examples

Routes tickets to self-service, standard, urgent, critical, or escalation.

96.2%Accuracy
42msBatch average / item

Content Moderation

4 outcomes · 5,000 synthetic examples

Classifies content as allow, flag, restrict, or remove.

91.5%Accuracy
41msBatch average / item

Gaming Chat

4 outcomes · 5,000 synthetic examples

Classifies messages as allow, mute, restrict, or ban.

91.0%Accuracy
34msBatch average / item

Marketplace Listings

4 outcomes · 5,000 synthetic examples

Reviews listings as approve, flag, restrict, or reject.

94.3%Accuracy
33msBatch average / item

Each benchmark starts with 5,000 synthetic examples. The data has uneven class distributions and 5–8% label noise. Some edge cases are left out.

We train six baselines on the original training data. Sparkient uses an LLM to relabel training examples and create extra examples for missing cases. It then trains the compiled model. We evaluate the baselines and Sparkient on the same held-out synthetic test set. The baselines use structured fields only, while Sparkient also uses a text encoder, so their F1 scores are not a matched text-model comparison.

Full methodology and all results →

Train and test your first model free

Paid plans start at $19 a month and include monthly credits. Decisions, training, and example generation use those credits.

Free
$0

Train and test one model

5,000 credits

  • 1 decision type
  • 250 total decisions
  • Community support
Start free
$19/mo

For individual developers

10,000 credits/mo

  • 2 decision types
  • Generate and label examples
  • Train and deploy models
Start free
$199/mo

For small production teams

50,000 credits/mo

  • 3 decision types
  • Everything in Developer
  • Email support
Start free
$599/mo

For growing products

200,000 credits/mo

  • 10 decision types
  • Local model export
  • Priority support
Start free
$1,999/mo

For high-volume deployments

1,000,000 credits/mo

  • 50 decision types
  • Dedicated support
Contact Sales

A training run uses 2,000 credits. Generating and labelling examples uses additional credits.

Founder

Built by a technical founder with 15 years of software experience

Peter Dobson has spent 15 years building software. His previous work includes web products used by more than one million people a month and a multi-user VR platform.

He also built and ran a national retail business with 64 locations and £20M in annual revenue.

He built Sparkient's model training, API, dashboard, and developer tools himself. The product is deployed, pre-revenue, and now being tested with developers.

FAQ

Common questions

Sparkient uses a large language model (LLM) to create or label examples. It trains a small model for one repeated decision. That model handles normal requests. If the cloud model is unsure, it can ask an LLM.

Across four published synthetic benchmarks, the compiled stage measured 33–42ms average time per item in batched runs. The current runner does not measure per-request p95. Simple rules can return in under 1ms, while an optional LLM fallback takes longer. Test the full API with your own workload before setting a production target.

You can upload labelled examples or ask Sparkient to create a starting set. Sparkient handles training, evaluation, and deployment. You still need to define the decision and review the results before production.

Yes. You can use the dashboard or REST API directly. A coding agent is another way to evaluate and set up Sparkient.

Sparkient's core API and data services run in Google Cloud's europe-west2 region. Data is encrypted in transit and at rest and isolated by organisation. Example generation and the optional LLM fallback use Google's global model endpoint, so review that path if you have strict residency requirements. You can export or delete account data through the API.

Decisions, training, examples, and model serving use credits. A training run uses 2,000 credits. The free trial includes 5,000 credits, one decision type, and 250 decisions. Paid plans include monthly credits, with optional top-ups.

See whether Sparkient fits your project.

Paste our audit prompt into your coding agent. If it finds a suitable repeated decision, you can test Sparkient free.