For developers using coding agents

Fast models for decisions your software makes repeatedly.

Train a task-specific model for routing, moderation, scoring, approval, or another fixed set of outcomes.

Your coding agent can inspect repeated rules and live LLM calls in the project, then tell you whether one candidate is worth testing.

Ask your agent →Try the Playground →

Hobby project or production app — fit depends on the decision, not the company size

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

Agent-led evaluation

Let the agent inside your codebase check the fit

It knows the architecture, the hard-coded decisions, and the places where an LLM call would sit in the runtime path. Give it one clear question.

Copy this prompt

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

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

Good signals

  • A repeated decision with a small, structured set of outcomes
  • Text or behavioural nuance that simple rules miss
  • Classification, routing, moderation, scoring, approval, or gating
  • A runtime path where calling an LLM every time is too slow or expensive

Keep it simple when

  • A deterministic rule that ordinary code already handles correctly
  • Generating prose, images, code, or other open-ended content
  • A genuinely one-off decision
  • A problem without stable outcomes that can be evaluated for accuracy

Weekend projects, prototypes, and commercial products can all qualify. The decision matters more than the company size.

How It Works

Define, train, and deploy a model

Bring examples or start with none. Define the outcome you need, measure the model on your own cases, then decide whether it belongs in the project.

1

Define

Create a decision type — the possible outcomes, your input fields, and any rules that should always apply. Via API, MCP, or dashboard.

2

Teach

Bring your own training data, or start with none — our LLM teacher can generate thousands of labelled examples from your definition alone.

3

Compile

We train a fast, standalone model on the labelled decisions. The compiled model handles the normal runtime path without calling an LLM.

4

Deploy

Call the API for credit-metered compiled decisions. The compiled path targets under 100ms; measure it on your workload. Optional LLM escalation handles configured uncertain cloud cases.

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 shape
{
  "decision": "approve",
  "confidence": 0.94,
  "latency_ms": 3.2,
  "reason_codes": ["CONTENT_SAFE", "TRUSTED_USER"],
  "escalate": false
}

Start with one measured decision, then integrate only if it earns its place.

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, provider, and network
Under-100ms compiled-path target; test your workload
Billing
Provider usage on every call
Operations use monthly plan credits
Customisation
Prompted for the task
Trained on your policy and examples
Uncertain cases
Handled by the same live model
Optional live-LLM escalation in the cloud path

Benchmarks

Results from four synthetic benchmarks

Each benchmark used 5,000 synthetic examples. The timing runner divided one batch duration by its item count; it did not measure per-request p95. These models have not 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 and a deterministic 80/20 split. Controlled label noise is added to the training rows. The held-out rows retain their generator-assigned reference labels.

Five traditional machine-learning models and one hand-written rules baseline are tested on the same held-out rows as Sparkient. Those trained baselines use structured fields only, while Sparkient also uses a text encoder. The comparison measures the complete pipelines; it does not isolate the benefit of one training step.

The reported 33–42ms values are average time per item from batched runs. The current runner does not measure individual-request p95, network time, or customer production traffic.

Full methodology and all results →

Start with a real project, not an enterprise contract

The $19 Developer plan is the self-serve entry point. Higher tiers add capacity as the application grows.

Free
$0

Get started

5,000 one-time credits

  • 1 decision type
  • 250 total decisions
  • Playground access
  • Under-100ms compiled-stage target
  • Community support
Start Free Trial
Best for builders
$19/mo

For hobby and early-stage projects

10,000 credits/mo

  • 2 decision types
  • Usage draws from included credits
  • No 250-decision trial cap
  • Generate & label examples
  • Model training & deployment
  • Dashboard analytics
Start Developer
Starter
$199/mo

For teams getting started

50,000 credits/mo

  • 3 decision types
  • Usage draws from included credits
  • No 250-decision trial cap
  • Generate & label examples
  • Model training & deployment
  • Email support
Start Free Trial
Production
$599/mo

For scaling products

200,000 credits/mo

  • 10 decision types
  • Usage draws from included credits
  • Everything in Starter
  • Edge bundle export
  • Priority support
Start Free Trial
High volume
$1,999/mo

For high-volume deployments

1,000,000 credits/mo

  • 50 decision types
  • Usage draws from included credits
  • Everything in Growth
  • Dedicated support
Contact Sales

Model compilation uses 2,000 credits per run. Example generation and labelling are billed separately.

Our Story

Why we built Sparkient

Sparkient began with Peter Dobson's work on systems where speed and decision quality both mattered. Live LLM calls brought useful judgment, but also placed model latency, token usage, and a provider dependency inside every repeated request.

The same design gap kept appearing. Rules were fast but became brittle when meaning and context mattered. Live LLMs were flexible, but not every bounded choice justified a generative model call. The opportunity was a measured decision layer between those two paths.

The insight was simple: use the LLM as an offline teacher. Turn a clear policy into labelled examples, train a task-specific model, and test whether that model can handle the normal path. Four public domains measured 33–42ms average time per item in batched runs, with optional LLM escalation kept explicit for uncertain cloud decisions.

“We turned repeated AI judgement into a fast, measurable decision system.”

— Sparkient

FAQ

Common questions

Sparkient uses a large language model (LLM) to create or label examples, then trains a small model for one repeated decision. The compiled model handles normal requests. Configured low-confidence cloud decisions can optionally ask an LLM.

Live-model APIs typically meter tokens or requests each time they are called. Sparkient uses LLMs during training, then serves the repeated decision from a compiled model. Plans include a predictable monthly credit allocation used by decisions, training, example generation, and model serving, so costs remain visible without pretending usage is free.

Across four controlled 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 bring your own labelled examples or generate a synthetic starting set with an LLM teacher. Sparkient manages generation, labelling, training, evaluation output, and deployment, so you do not need to build that infrastructure yourself. You still need a clear policy and must review representative held-out results before production use.

Yes. Sparkient works as a standard REST API. You can create decision types in the dashboard, call the /decide endpoint from any language, and manage everything without an AI agent. Agents are one integration path — not the only one.

Sparkient's core API and data services are configured in Google Cloud's europe-west2 region. Teacher generation and optional LLM escalation currently use Google's global model endpoint, so projects with strict data-residency requirements should review that path before enabling it. Data is encrypted in transit and at rest, isolated by organisation, subject to configurable retention, and exportable or deletable through the account API.

Each training run uses 2,000 credits from your balance. This covers model compilation — the process of training and exporting your decision model. Example generation and labelling are billed separately as individual API calls. Trial users get 5,000 credits — enough to train and test one model.

The free trial includes 5,000 one-time credits, 1 decision type, and 250 total decisions. This gives you enough to train and test one candidate. Paid plans remove the hard trial decision counter, while each operation continues to draw from the plan's included credit balance.

Yes. Fit depends on the decision, not whether the project is commercial. A hobby project can benefit from semantic classification, routing, moderation, or agent decision gates. The $19 Developer plan includes 10,000 monthly credits and two decision types so developers can run a real project without moving straight to a production tier.

Keep simple deterministic rules in ordinary code. Use a generative model for prose, images, code, or other open-ended output. Sparkient is intended for repeated, measurable decisions with stable outcomes, and a project review may conclude that it is not useful.

Start with a project review.

Ask the coding agent that already understands your project, then start free if it finds a genuine fit.

Ask your agent →Start free →