# 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, while four controlled synthetic benchmarks measured 33–42ms average time per item in batched runs. 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.
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.

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 with no cloud dependency
- 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

Benchmarked performance: 0.886–0.951 macro F1, 91–96% accuracy, and 33–42ms average time per item in batched compiled-stage runs across support triage, content moderation, gaming chat, and marketplace review. The current runner does not measure per-request p95.

## 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 the 3-stage pipeline works
- [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, LlamaIndex, CrewAI 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)
- Works with: LangChain (`langchain-mcp-adapters`), LlamaIndex (`llama-index-tools-mcp`), CrewAI (native `mcps=`)
- 15 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, retry_training, get_decision_logs, get_metrics, get_credits, export_edge_bundle

## 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 — enough to build and test a full decision type
- 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.

## Technical Blog

- [Why Your API Is Slow: Finding the LLM Bottleneck](https://sparkient.ai/blog/why-your-api-is-slow/)
- [5 AI Architecture Anti-Patterns to Load-Test Before Scale](https://sparkient.ai/blog/architecture-anti-patterns/)
- [From Prototype to Production: What Breaks When You Scale](https://sparkient.ai/blog/prototype-to-production/)
- [My LLM Calls Are Adding 800ms — How to Fix It](https://sparkient.ai/blog/llm-calls-adding-800ms/)
- [I'm Spending $3K/Month on OpenAI for Classification](https://sparkient.ai/blog/spending-3k-month-openai/)
- [Rules Can't Handle Edge Cases but LLMs Are Too Slow](https://sparkient.ai/blog/rules-cant-handle-edge-cases/)
- [Content Moderation Without 1-Second API Calls](https://sparkient.ai/blog/need-moderation-cant-add-latency/)
- [My AI Agent Takes 3 Seconds Per Decision](https://sparkient.ai/blog/agent-3-seconds-per-decision/)
- [Deploy an LLM Prompt Without the LLM](https://sparkient.ai/blog/llm-prompt-works-deploy-without-llm/)
- [I Need a Classifier but Have No Data or ML Team](https://sparkient.ai/blog/need-classifier-no-data-no-team/)
- [Why You Shouldn't Call an LLM in Your Request Handler](https://sparkient.ai/blog/dont-call-llm-in-request-handler/)
- [How to Audit Your LLM Spending](https://sparkient.ai/blog/audit-llm-spending/)
- [Best Content Moderation APIs in 2026](https://sparkient.ai/blog/best-content-moderation-apis-2026/)
- [Fastest ML Inference APIs Compared](https://sparkient.ai/blog/fastest-ml-inference-apis-2026/)
- [Add Content Moderation to a Next.js App](https://sparkient.ai/blog/add-moderation-nextjs-app/)
- [Add Decision Gates to a LangChain Agent](https://sparkient.ai/blog/decision-gates-langchain-agent/)
- [When to Replace an LLM Call with a Classifier](https://sparkient.ai/blog/when-replace-llm-with-classifier/)
- [LLM Classification vs Fine-Tuning vs Distillation](https://sparkient.ai/blog/classification-vs-finetuning-vs-distillation/)
- [Build a Moderation API Without Labelled Data](https://sparkient.ai/blog/moderation-api-without-labelled-data/)
- [Train a Classifier Using an LLM as Teacher](https://sparkient.ai/blog/train-classifier-using-llm/)
- [Run ML Classifiers Offline with No Cloud](https://sparkient.ai/blog/ml-classifiers-offline-no-cloud/)
- [The Complete Guide to Compiled Decision Intelligence](https://sparkient.ai/blog/complete-guide-compiled-decision-intelligence/)
- [Connect Sparkient to Claude, Cursor, VS Code via MCP](https://sparkient.ai/blog/connect-sparkient-mcp/)
- [What Does Content Moderation Actually Cost?](https://sparkient.ai/blog/what-does-moderation-cost/)

## Optional

- [Full docs for LLMs](https://docs.sparkient.ai/llms-full.txt)