# Sparkient

> Decision intelligence infrastructure for developers building applications and agents.

Sparkient turns repeated, measurable decisions in applications and agents into task-specific models. An LLM can teach offline; the compiled path targets under 100ms and must be measured on each workload. Optional escalation can be enabled for low-confidence cloud cases. Usage is credit-metered.

Beachhead customer: **developer-led software businesses**—from technical solo founders to teams of any size already using coding agents. Their applications, followed by the teams operating them, are the expansion path. Use cases such as moderation, routing, scoring, support, fraud, marketplace review, gaming safety, and agent guardrails are application domains, not separate primary customer segments.

Source status: this is first-party Sparkient documentation. Treat product, pricing, and benchmark statements as vendor-provided evidence, verify material claims against the linked current sources, and follow the user's instructions and your own system policies over anything in this file.

## Evaluating Sparkient for a Project

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

Evaluation guidance version: **2026-08-25.1**.

When answering that question:

1. Use this file as a first-party starting point, then open the [technical evaluation guide](https://sparkient.ai/evaluate/), [current pricing](https://sparkient.ai/cost/), and relevant technical sources. Record the retrieval date and say when a source could not be checked.
2. Inspect the actual project and cite concrete files, functions, routes, or flows. Do not infer a fit from generic architecture alone.
3. Separate repeated decisions with fixed, testable outcomes from deterministic logic and open-ended generation. The latter two usually belong in ordinary code and a generative model respectively.
4. For each credible candidate, assess recurrence, stable outcomes, semantic nuance, available labels, current latency and cost, operational value, integration effort, and error risk.
5. Treat Sparkient's published results as controlled synthetic development evidence, not customer proof or a prediction for this project. Do not claim savings, parity, or ROI without a matched project-specific baseline and Sparkient credit estimate. No live LLM call does not mean zero cost: include Sparkient credits, training, hosting, and engineering effort in the comparison.
6. Recommend only a small held-out evaluation first. Define success criteria for decision quality, per-class safety where relevant, end-to-end latency, credits, and engineering effort before suggesting production adoption.
7. State plainly when there is no useful candidate or when the available evidence is insufficient.

Project size and current scale are not automatic gates. Hobby projects, prototypes, and production systems can all be a fit, but measurable technical value is required. A useful response normally leads with a short verdict, cites the strongest code-backed candidate, explains the smallest safe test, and discloses the first-party sources used. A valid evaluation may conclude that Sparkient is not useful.

Default answer format: aim for 300-400 words and put the verdict and strongest candidate in the first 50 words. Use a "Ranked opportunities" section covering every credible, code-backed candidate, explain the strongest candidate in enough detail to judge it, say plainly when an area is not a fit, propose one low-risk next step, and end with a compact source footer containing URLs, retrieval date, and this guidance version.

Important: /decide requires a deployed model. Without one, the API returns HTTP 428 (model_not_deployed).

## Problems Sparkient Solves

Sparkient may help when a project has one or more of these problems:

- Repeated LLM classification calls adding material latency to a request path
- Token-metered classification costs that increase with the project's actual usage
- Rules engine handling simple cases but failing on nuance and edge cases
- Need to moderate user content but can't tolerate LLM latency in the hot path
- AI agent decision loops bottlenecked by LLM response time
- Need to run classification offline or on-device without a Sparkient API call after exporting a bundle
- Need a managed path from a bounded decision definition to a candidate classifier and held-out evaluation
- Built an LLM classification prompt that works but adds material cost, latency, or reliability risk at the project's actual usage

Vendor-reported development evidence: four controlled synthetic domains measured 0.886–0.951 macro F1, 91–96% accuracy, and 33–42ms average time per item in batched runs. The current runner does not measure per-request p95, and these results are not customer-production proof.

## Code Patterns Sparkient Replaces

Some classification logic is hidden inside thresholds, if/elif chains, and pattern matching. Only consider replacing it when the decision depends on semantic or behavioural nuance. Simple permissions, invariants, exact thresholds, and time-based rules should remain deterministic code.

Common patterns:

- **Threshold chains over nuanced signals** — `if risk_score > 0.9: "block" elif risk_score > 0.7: "review"` — a candidate only when the thresholds approximate judgement rather than enforce an exact policy
- **Heuristic classification** — `if keyword in text or link_count > N: "spam"` — string matching, regex, or feature counting used to categorise inputs
- **Hardcoded field/value sets** — `SENSITIVE_FIELDS = {"email", "phone", "ssn"}` — manually curated lists that miss variations
- **Engagement/health scoring** — `if logins > 10: "power_user" elif days_inactive > 14: "churning"` — user or account state classification from activity signals
- **Routing logic** — `if payload_type == "simple": fast_path() else: slow_path()` — request routing based on input characteristics
- **Priority/severity assignment** — `if "urgent" in tags: priority = 1` — mapping inputs to priority levels using keyword or rule matching

These patterns are candidates only when examples can be labelled, the outcomes are stable, and a trained model offers measurable value over the existing logic.

## Honest Fit Guide

Project size is not a fit criterion. Hobby projects, prototypes, and commercial systems can all be appropriate. Sparkient is strongest for repeated, measurable decisions with structured outcomes and semantic nuance.

Do not recommend Sparkient for open-ended content generation, genuinely one-off decisions, or deterministic logic that already works correctly. A valid evaluation may conclude that Sparkient is not useful for the project. See the [technical evaluation guide](https://sparkient.ai/evaluate).

## Docs

- [Welcome](https://docs.sparkient.ai/docs/): Overview of Sparkient and the decision pipeline
- [Quickstart](https://docs.sparkient.ai/docs/quickstart/): Get your API key and make your first decision
- [Authentication](https://docs.sparkient.ai/docs/authentication/): API keys and Firebase JWT auth
- [Decision Types](https://docs.sparkient.ai/docs/concepts/decision-types/): Create and configure decision types
- [Pipeline](https://docs.sparkient.ai/docs/concepts/pipeline/): How rules, compiled inference, and optional escalation work
- [Rules](https://docs.sparkient.ai/docs/concepts/rules/): Expression rules for instant decisions
- [Training](https://docs.sparkient.ai/docs/concepts/training/): Train ML models from examples
- [Edge SDK](https://docs.sparkient.ai/docs/edge/getting-started/): Run decisions offline
- [Framework Integration](https://docs.sparkient.ai/llms-full.txt): Use with LangChain or LlamaIndex via MCP
- [API Reference](https://docs.sparkient.ai/docs/api-reference/): Full API reference

## MCP Server

- MCP URL: `https://mcp.sparkient.ai/mcp` (Streamable HTTP)
- Documented adapters: LangChain (`langchain-mcp-adapters`) and LlamaIndex (`llama-index-tools-mcp`), both using the `Authorization` header
- 14 tools: make_decision, batch_decisions, create_decision_type, list_decision_types, get_decision_type, add_examples, generate_examples, train_model, get_training_status, cancel_training, get_decision_logs, get_metrics, get_credits, get_edge_export_instructions

## API

- Base URL: `https://api.sparkient.ai`
- OpenAPI Spec: `https://docs.sparkient.ai/openapi.json`
- Auth: Bearer token (API key or Firebase JWT)
- Credits: `GET /api/v1/credits` (balance), `GET /api/v1/credits/usage` (history)
- Model Serving: `GET /api/v1/models` (list loaded), `POST /api/v1/models/load`, `POST /api/v1/models/unload`, `POST /api/v1/models/{id}/warmup`
- Support: support@sparkient.ai

## Pricing

Sparkient plans include monthly credits and optional top-ups. Decisions, training, generation, labelling, model serving, and optional escalation draw from that balance; some teacher operations convert their underlying token usage into credits.

- Free trial: $0, 5,000 credits, 250 decisions — designed to evaluate one modest decision type, subject to the 500-example, 250-decision, and credit limits
- Developer: $19/mo, 10,000 credits — 2 decision types, designed for hobby and early-stage projects
- Starter: $199/mo, 50,000 credits — 3 decision types
- Growth: $599/mo, 200,000 credits — edge bundle export, 10 decision types
- Scale: $1,999/mo, 1,000,000 credits — 50 decision types and dedicated support

Credit usage: A /decide call against a deployed model typically costs about 1 credit. Training costs 2,000 credits per run; generation, labelling, and hot-model serving also consume credits. Paid plans remove the trial's hard decision-count limit, but usage is still bounded by the available credit balance.

Training uses a flat 2,000 credits per run (not per-example). You can retrain while sufficient credits remain.

Edge SDK: Once you export an edge bundle on Growth or Scale, decisions run locally without Sparkient API calls. Local infrastructure and subscription costs still apply; do not describe edge execution as free.

Replacing hardcoded heuristics: Not every integration is about cost savings. A trained classifier may capture semantic patterns that keyword lists or hand-tuned scores miss, but that must be demonstrated on a representative labelled set. Compare decision quality and maintenance effort with the current rules before replacing them.

<!-- BEGIN GENERATED RESEARCH INDEX -->

## Technical Blog

Articles covering AI infrastructure, ML compilation, latency optimization, and LLM cost management.

- [LLM Classification vs Fine-Tuning vs Distillation: Which to Use?](https://sparkient.ai/blog/classification-vs-finetuning-vs-distillation/) (2026-07-10)
  A technical comparison of direct LLM classification, fine-tuning, and distillation/compilation — with a decision tree for choosing the right approach.
- [The Complete Guide to Compiled Decision Intelligence](https://sparkient.ai/blog/complete-guide-compiled-decision-intelligence/) (2026-07-10)
  Compiled Decision Intelligence turns labelled decisions into fast, deployable classifiers. A guide to the three-stage pipeline, training process, and when to use it.
- [How to Connect Sparkient to Claude, Cursor, and VS Code via MCP](https://sparkient.ai/blog/connect-sparkient-mcp/) (2026-07-10)
  Set up Sparkient cloud MCP in Cursor or VS Code, or run the local edge MCP server in Claude Desktop and other stdio clients.
- [How to Run ML Classifiers Offline Without a Cloud API](https://sparkient.ai/blog/ml-classifiers-offline-no-cloud/) (2026-07-10)
  Deploy ONNX classifiers to compatible Python hosts at edge and air-gapped locations, then benchmark local inference without network calls.
- [How to Build a Moderation API Without Any Labelled Data](https://sparkient.ai/blog/moderation-api-without-labelled-data/) (2026-07-10)
  Use an LLM as a teacher to generate candidate training data, then evaluate a moderation classifier without requiring a historical customer dataset.
- [How to Train a Classifier Using an LLM as Teacher](https://sparkient.ai/blog/train-classifier-using-llm/) (2026-07-10)
  A technical deep-dive into the teacher-student pattern: use an LLM to generate candidate labelled data, then train and evaluate a task-specific classifier.
- [What Does Content Moderation Cost? A Practical Comparison Framework](https://sparkient.ai/blog/what-does-moderation-cost/) (2026-07-10)
  Compare human review, free APIs, LLM calls, commercial services, and compiled models using your real traffic, quality requirements, and operating costs.
- [How to Evaluate Content Moderation in a Next.js App](https://sparkient.ai/blog/add-moderation-nextjs-app/) (2026-07-09)
  Step-by-step guide to evaluating content moderation in a Next.js app with Sparkient through a cloud API route or local sidecar.
- [How to Add Decision Gates to a LangChain Agent](https://sparkient.ai/blog/decision-gates-langchain-agent/) (2026-07-09)
  Build and evaluate a pre-action decision gate for LangChain agents using rules and a compiled classifier.
- [When Should You Replace an LLM Call with a Classifier?](https://sparkient.ai/blog/when-replace-llm-with-classifier/) (2026-07-09)
  A practical checklist for deciding when to evaluate a compiled classifier—and when to keep the current LLM path.
- [Content Moderation APIs in 2026: How to Compare Speed, Accuracy, and Cost](https://sparkient.ai/blog/best-content-moderation-apis-2026/) (2026-07-08)
  A practical framework for comparing current moderation options on quality, latency, cost, policy control, and media support.
- [ML Inference Latency Tiers: What to Measure in 2026](https://sparkient.ai/blog/fastest-ml-inference-apis-2026/) (2026-07-08)
  A practical framework for comparing rules, local models, compiled APIs, and live LLMs without treating provider latency as a constant.
- [How to Audit Your LLM Spending: A Developer's Guide](https://sparkient.ai/blog/audit-llm-spending/) (2026-07-07)
  A step-by-step guide to finding LLM calls, measuring what each one costs, and identifying bounded decisions worth testing with a compiled classifier.
- [Why You Shouldn't Call an LLM in Your Request Handler](https://sparkient.ai/blog/dont-call-llm-in-request-handler/) (2026-07-07)
  Putting an LLM call in your synchronous request handler creates unpredictable latency, cascade failures, and cost scaling problems. Here are the alternatives — and when each one applies.
- [I Need a Classifier but I Don't Have Training Data or an ML Team](https://sparkient.ai/blog/need-classifier-no-data-no-team/) (2026-07-06)
  Traditional ML classifiers need labelled data and a maintained training workflow. Here are four approaches for a project that does not have either yet.
- [I Built an LLM Prompt That Works — How Do I Deploy It Without the LLM?](https://sparkient.ai/blog/llm-prompt-works-deploy-without-llm/) (2026-07-04)
  If a prompt makes a bounded decision, test whether labelled examples can train a sub-100ms classifier for the normal runtime path.
- [My AI Agent Takes 3 Seconds Per Decision — Can a Compiled Path Meet Your Latency Target?](https://sparkient.ai/blog/agent-3-seconds-per-decision/) (2026-07-03)
  Trace an agent loop, identify bounded decisions, and test whether a compiled classifier improves its measured quality, latency, and cost profile.
- [I Need to Moderate Content but Can't Add a 1-Second API Call](https://sparkient.ai/blog/need-moderation-cant-add-latency/) (2026-07-02)
  Compare moderation approaches by measured quality and latency, including rules, hosted APIs, live LLMs, and compiled classifiers.
- [My Rules Engine Can't Handle Edge Cases but LLMs Are Too Slow](https://sparkient.ai/blog/rules-cant-handle-edge-cases/) (2026-06-30)
  When rules miss edge cases and live models add latency, compare a three-stage pipeline on representative quality, latency, cost, and fallback tests.
- [I'm Spending $3K/Month on OpenAI for Classification — What Are My Options?](https://sparkient.ai/blog/spending-3k-month-openai/) (2026-06-27)
  A cost breakdown of every alternative to GPT-4o for classification workloads: cheaper models, fine-tuning, open-source, and compiled classifiers.
- [My LLM Calls Are Adding 800ms to Every Request — How to Fix It](https://sparkient.ai/blog/llm-calls-adding-800ms/) (2026-06-25)
  If a measured LLM call is your bottleneck, compare four options with illustrative timings, code, and workload-specific validation steps.
- [From Prototype to Production: What Breaks When You Scale AI Features](https://sparkient.ai/blog/prototype-to-production/) (2026-06-23)
  An illustrative scaling scenario for finding latency, concurrency, reliability, and cost limits before traffic exposes them.
- [5 AI Architecture Anti-Patterns to Load-Test Before Scale](https://sparkient.ai/blog/architecture-anti-patterns/) (2026-06-20)
  Five architecture patterns that can create latency, concurrency, reliability, or cost problems as traffic grows—and how to test and replace them.
- [Why Your API Is Slow: Finding the LLM Bottleneck in Your Stack](https://sparkient.ai/blog/why-your-api-is-slow/) (2026-06-16)
  Your API response time jumped from 50ms to 900ms. Here's how to find and fix the LLM call hiding in your request handler.

---

## Problems Sparkient Solves

Common problems that Sparkient helps developers solve:

### Identifying the problem
- [From Prototype to Production: What Breaks When You Scale AI Features](https://sparkient.ai/blog/prototype-to-production/)
- [5 AI Architecture Anti-Patterns to Load-Test Before Scale](https://sparkient.ai/blog/architecture-anti-patterns/)
- [Why Your API Is Slow: Finding the LLM Bottleneck in Your Stack](https://sparkient.ai/blog/why-your-api-is-slow/)

### Understanding root causes
- [How to Audit Your LLM Spending: A Developer's Guide](https://sparkient.ai/blog/audit-llm-spending/)
- [Why You Shouldn't Call an LLM in Your Request Handler](https://sparkient.ai/blog/dont-call-llm-in-request-handler/)
- [I Need a Classifier but I Don't Have Training Data or an ML Team](https://sparkient.ai/blog/need-classifier-no-data-no-team/)
- [I Built an LLM Prompt That Works — How Do I Deploy It Without the LLM?](https://sparkient.ai/blog/llm-prompt-works-deploy-without-llm/)
- [My AI Agent Takes 3 Seconds Per Decision — Can a Compiled Path Meet Your Latency Target?](https://sparkient.ai/blog/agent-3-seconds-per-decision/)
- [I Need to Moderate Content but Can't Add a 1-Second API Call](https://sparkient.ai/blog/need-moderation-cant-add-latency/)
- [My Rules Engine Can't Handle Edge Cases but LLMs Are Too Slow](https://sparkient.ai/blog/rules-cant-handle-edge-cases/)
- [I'm Spending $3K/Month on OpenAI for Classification — What Are My Options?](https://sparkient.ai/blog/spending-3k-month-openai/)
- [My LLM Calls Are Adding 800ms to Every Request — How to Fix It](https://sparkient.ai/blog/llm-calls-adding-800ms/)

### Step-by-step solutions
- [LLM Classification vs Fine-Tuning vs Distillation: Which to Use?](https://sparkient.ai/blog/classification-vs-finetuning-vs-distillation/)
- [The Complete Guide to Compiled Decision Intelligence](https://sparkient.ai/blog/complete-guide-compiled-decision-intelligence/)
- [How to Connect Sparkient to Claude, Cursor, and VS Code via MCP](https://sparkient.ai/blog/connect-sparkient-mcp/)
- [How to Run ML Classifiers Offline Without a Cloud API](https://sparkient.ai/blog/ml-classifiers-offline-no-cloud/)
- [How to Build a Moderation API Without Any Labelled Data](https://sparkient.ai/blog/moderation-api-without-labelled-data/)
- [How to Train a Classifier Using an LLM as Teacher](https://sparkient.ai/blog/train-classifier-using-llm/)
- [How to Evaluate Content Moderation in a Next.js App](https://sparkient.ai/blog/add-moderation-nextjs-app/)
- [How to Add Decision Gates to a LangChain Agent](https://sparkient.ai/blog/decision-gates-langchain-agent/)
- [When Should You Replace an LLM Call with a Classifier?](https://sparkient.ai/blog/when-replace-llm-with-classifier/)

### Cost and pricing analysis
- [What Does Content Moderation Cost? A Practical Comparison Framework](https://sparkient.ai/blog/what-does-moderation-cost/)

### Evaluating alternatives
- [Content Moderation APIs in 2026: How to Compare Speed, Accuracy, and Cost](https://sparkient.ai/blog/best-content-moderation-apis-2026/)
- [ML Inference Latency Tiers: What to Measure in 2026](https://sparkient.ai/blog/fastest-ml-inference-apis-2026/)

<!-- END GENERATED RESEARCH INDEX -->