# NeoAI — Complete System Documentation and Knowledge Bundle Published: 2026-10-25 | Domain: recipes.neoai.solutions Format: Full machine-readable context file (llms-full.txt) for LLMs, autonomous agents, and AI search engines. > NeoAI captures how a company's best people get AI work done and applies it to every task, so work comes back right the first time at the lowest cost that meets the quality bar. It runs in the customer's own cloud (VPC), behind their existing AI gateway, with no change to how teams work. Pricing is gainshare: no measured savings, no fee. Every number across NeoAI documentation carries an explicit label: Estimate, Illustrative, Simulated, Public list prices, Worked example, Commitment, Commercial, or Pilot: to measure. NeoAI has no published customer results yet. Savings are measured per customer in a pilot. ================================================================================ TABLE OF CONTENTS ================================================================================ 1. How NeoAI Works: Distilled Recipes and Smart Delegation (/how-it-works/) 2. Comparison: NeoAI vs AI Gateways and LLM Routers (/vs-ai-gateways-and-routers/) 3. Comparison: NeoAI vs Portkey (/vs/portkey/) 4. Comparison: NeoAI vs LiteLLM (/vs/litellm/) 5. Comparison: NeoAI vs Model Routers (/vs/martian/) 6. Security & VPC Architecture (/security/) 7. Pricing & Gainshare Model (/pricing/ & /pricing.md) 8. Free Spend & Rework Audit (/audit/ & /audit.md) 9. Data: Frontier vs Small LLM Price Gap (/data/llm-price-gap/) 10. Methodology: Simulated Replay Token Economics (/methodology/simulated-replay/) 11. Guide: How to Reduce Enterprise LLM Costs Without Sacrificing Quality (/guides/reduce-llm-costs/) 12. Guide: Cost per Accepted Task Defined (/guides/cost-per-accepted-task/) 13. Guide: Model Cascading in AI Agents (/guides/model-cascading-agents/) 14. About NeoAI (/about/) 15. Master FAQ Compilation ================================================================================ --- # How NeoAI Works: Distilled Recipes and Smart Delegation Published: October 25, 2026 | NeoAI (https://recipes.neoai.solutions/how-it-works/) ## 1. Overview NeoAI learns how your best people get AI work accepted, then runs each step on the cheapest model that still passes your bar. Recipes capture the steps, context, tools and checks behind your accepted work. Delegation gives each step the model tier and effort it needs, and moves it up a tier only when a check fails. Proof line: Every number on this page is labelled Illustrative, Simulated or Pilot: to measure. NeoAI has no published customer results yet. The pilot measures yours. ## 2. AI Cost Has Three Terms. NeoAI Reduces All Three. Cost per accepted task = staff time * hourly rate + (attempts * cost per attempt) Recipes cut staff time and attempts. Delegation cuts cost per attempt. ### Scaling Company-Wide Throughput Company Throughput = Available Staff Hours / Staff Time per Accepted Task When reviewer rework drops from 26 min to 2 min, your team's capacity expands 13x. Employees stop manually intervening in retries, allowing the entire company to scale accepted output with existing headcount. ### Worked Example: Resume Screening (Illustrative) - Today (5 attempts on frontier model): - Attempts: #1 sent back, #2 edited, #3 sent back, #4 edited, #5 accepted - Staff rework time: 26 min - Model cost: $4.50 - Team throughput (20 staff): ~1,400 accepted tasks/month (choked by manual rework) - With NeoAI (1 attempt, split across tiers): - Attempts: S, S, M, F, S -> Accepted - Staff rework time: 2 min - Model cost: $0.80 - Team throughput (20 staff): 18,000+ accepted tasks/month (13x company throughput) Assumes 20 reviewers correcting between attempts, the same quality bar before and after, and list prices as of October 2026. The pilot replaces these with your measured values. ## 3. Recipes: Demonstrating the Distillation Process A recipe is not a prompt. It is a versioned, executable DAG compiled from your team's accepted runs, turning reviewer corrections into automated gates. ### The 4-Stage Distillation Cycle 1. Watch & Capture: Passively records your best reviewers' actions: prompts, retries, redline edits, and rejection rationales. 2. Mine Invariants: Analyzes differences between accepted and rejected runs to extract tacit rules human reviewers consistently enforce. 3. Codify & Gate: Translates human rules into discrete steps with automated assertion tests (e.g. source citations, schema validation). 4. Evaluate & Promote: Candidate versions run against held-out tasks. Ships as v14 only if pass rate beats v13 with fewer attempts. ### Concrete Distillation Demonstration: Reviewer Trace to Production Recipe 1. Raw Reviewer Edit Trace (Input): - Run #104 (24 min rework): - AI Draft: "Strong leadership experience and good cultural fit." - Reviewer Diff: "REJECT: Must cite exact CV quotes and verified project tenure. Strip subjective claims." 2. NeoAI Distillation Engine (Transformation): - Extracted Rule: Require verbatim quote from source document for each score. - Synthesized Gate: assert all(s.citations in cv_text for s in scores) - Resulting DAG: [cv-extract (Llama)] -> [rubric (Mid)] -> [bias-audit (Frontier)] -> [summary (Flash)] 3. Held-Out Evaluation Set & Promotion Gate (Verification): - Public prompt library: Pass rate 58%, Attempts 3.3 -> Dropped - Your in-house library: Pass rate 74%, Attempts 2.2 -> Dropped - Distilled from accepted work: Pass rate 93%, Attempts 1.2 -> Promoted and kept as v14 Held-out task evaluation, Illustrative. Every version is logged in your VPC and can be rolled back with one click. ## 4. Technical Architecture: In-VPC Complexity Routing & Dual-Track Execution A private planning agent decomposes incoming requests and delegates each sub-step to the lowest-cost model tier that passes your bar. ### The 4-Stage Technical Flow 1. Task Ingestion: Requests enter your in-VPC gateway via standard OpenAI/Anthropic API contract with zero code rewrites. 2. VPC Complexity Review: Planning engine analyzes task ambiguity, context depth, and error cost to decompose the task into discrete sub-steps. 3. Dual-Track Execution: - Complex & judgement steps route to Frontier models (Claude 3.5 Sonnet, GPT-4o, o1). - Simple, structured, or extraction steps route to Open-source / Cheaper models (Llama 3.3, Mistral, Flash) in-VPC at 90%+ lower cost. - Escalation safety net: If an open-source step fails an automated confidence or rubric check, it re-runs one tier up automatically. 4. Aggregation & Delivery: Recipe assertions validate each sub-output, aggregate the unified result, and return the completed accepted task to the user. ### Execution Plan (Resume Screening Example) - Step 1: Extract evidence from CV -> Open Source (Llama 3.3 / Flash) (Structured, easy to verify) - Step 2: Score against rubric -> Mid Tier (Judgement, bounded by rubric) - Step 3: Bias check & edge cases -> Frontier (Claude / GPT-4o) (Costly error tolerance) - Gate: 114 pass on Open Source, 6 borderline CVs escalate to Frontier. User sees a result, not an error. - Step 4: Aggregate & format summary -> Open Source (Flash) (Formatting from checked inputs) - Cost Index: 100 on frontier -> 17 routed by NeoAI (~20x price gap: frontier vs open-source). ## 5. Setup & Pilot: Verified on Your Workload, In Your VPC ### In-VPC Architecture & Security Boundary Deploys as a containerized service (Helm/Docker/Terraform) in your AWS, GCP, or Azure VPC behind your existing AI Gateway (LiteLLM, Portkey, Kong). Your upstream API keys stay in your KMS. Prompts, schemas, and recipes never leave your boundary. Zero data retention. ### 2-Week Measured Pilot Protocol - Week 1 (Baseline): Passive mirror mode logs your actual baseline rework hours, attempts, and token spend with 0 disruption. - Week 2 (Dual-Track): Runs distilled recipes on held-out tasks. Full side-by-side reconciliation delivered with audit replay logs. ### Guaranteed ROI & Full Recipe Portability No measured savings, no fee. If the pilot does not prove cost reduction and manual rework elimination, you owe nothing. All recipes are exported as open JSON/YAML DAGs that you own and run forever with zero vendor lock-in. ### Enterprise Measured Dimensions (Baseline vs NeoAI) 1. Cost per accepted task (Model spend plus reviewer rework payroll) -> Target: 60-80% overall reduction 2. Company throughput (Accepted outputs per employee per month) -> Target: 5x-13x capacity expansion 3. Attempts to acceptance (Model runs before reviewer sign-off) -> Target: 1.0 - 1.2 (vs 3.0+ baseline) 4. Staff rework time (Hours spent correcting, re-prompting, or editing) -> Target: 80-90% manual rework eliminated 5. Escalation safety rate (Steps re-routed from open-source to frontier) -> Target: < 6% (reported per step) A cheaper output that fails your bar counts as a failure, not a saving. ## 6. Limits and Questions - What we do not claim: There are no published customer results yet. Simulated replays show how routing behaves, not that your outputs would pass your bar. Savings depend on your task mix. New task types and low-volume tasks start cold. - Who decides what counts as good? You do, through your reviewers' accept or reject decisions captured before the pilot starts. - What if a cheaper model gets it wrong? The step's checks catch it and the step re-runs one tier up automatically. The user sees a result, not an error. - Do recipes work across task types? Related tasks that share blocks start ahead. Unrelated tasks start from the beginning. - Can I take my recipes with me? Yes. They are stored in your cloud, exportable in open JSON/YAML formats, and every version is logged. Closing CTA: See your own numbers in about 2 weeks, free. No measured savings, no fee. Get the free audit -> https://recipes.neoai.solutions/audit/ --- # NeoAI vs AI gateways and LLM routers: one model per request, or the right setting for every step Published: 2026-10-25 | NeoAI (https://recipes.neoai.solutions/vs-ai-gateways-and-routers/) > AI gateways and LLM routers choose one model for each request. NeoAI works behind them: it splits the task into sub-steps and tunes the model, reasoning effort, context and budget for each step, using recipes learned from your own usage. It complements a gateway rather than replacing it. ## The difference in one table The categories below describe typical behaviour of each kind of tool, not any single vendor. Check any specific product against your own requirements. Typical behaviour by category. NeoAI column reflects the product design; pilot results are to be measured. | Question | AI gateway | LLM router | NeoAI | | --- | --- | --- | --- | | What does it decide? | Where a request goes, plus keys, limits and logging | Which model answers each request | Model tier, reasoning effort, context and budget for each sub-step | | Unit of decision | Request | Request | Sub-step of a task | | Learns from your company's work | Not typically | Typically learns from general preference or benchmark data | Yes: recipes built from your accepted outputs | | Reduces retries and rework | No | Not directly | Yes: recipes cut attempts per task Pilot: to measure | | Handles a cheaper model failing | Fallback on errors | Fallback or re-route | Escalates the step on a failed confidence or quality check | | Where it sits | In front of your models | In front of your models, or inside the gateway | Behind your existing gateway, in your VPC | | Changes to your workflow | Endpoint change | Endpoint change | One endpoint change, no workflow change | ## What a gateway or router does well A gateway centralises access: one place for credentials, rate limits, caching, logging and provider failover. A router adds a decision about which model should answer each request. Both are useful, and NeoAI is designed to leave them in place. Your apps keep calling the gateway you already run. ## What a per-request decision cannot see A single request is often one step in a longer task. Choosing a model per request cannot change how many attempts the task takes, which context each step needs, or how much reasoning effort a step deserves. Those are the places where rework and overspend come from: the same task gets different quality across teams, several attempts per task, and a frontier model with deep reasoning used on simple steps on every attempt. NeoAI works at the step level. It breaks a task into sub-steps, scores how hard each is, and applies a recipe learned from your own accepted outputs. Read how recipes and delegation work. ## How the two fit together - Your apps (chat, agents, internal tools) call your AI gateway as today. - Your gateway is unchanged and still handles credentials, limits and logging. - NeoAI runs behind it in your VPC, with a recipe store you own, an evaluation harness and an audit log. - Your model providers receive each step on the small, mid or frontier tier it was assigned. ## When you probably do not need NeoAI - Your monthly LLM spend is well under $20k, where an audit costs more attention than it saves. - You run one simple, uniform workload that a single small model already handles at your quality bar. - You are still choosing providers. Start with a gateway; add NeoAI once usage is steady. NeoAI is built for teams spending $20k to $500k a month on LLMs, and for enterprise AI platform teams who need answers for the CEO, CTO, CIO and CFO. The way to find out is a free audit on your own usage. ## Frequently Asked Questions ### Do I need to replace my AI gateway to use NeoAI? No. NeoAI sits behind your existing gateway. Adoption is one endpoint change with no change to how teams work. ### Is NeoAI an LLM router? Not in the usual sense. A router picks one model per request. NeoAI tunes the model tier, reasoning effort, context and budget for each sub-step of a task, using recipes learned from your own usage. ### What can NeoAI do that a router cannot? It reduces retries and rework by applying recipes learned from your accepted outputs, and it carries learning across related tasks. A per-request router does not change how many attempts a task takes. ## Canonical URL https://recipes.neoai.solutions/vs-ai-gateways-and-routers/ --- # NeoAI vs Portkey: API gateway management versus in-VPC step-level delegation Published: 2026-10-25 | NeoAI (https://recipes.neoai.solutions/vs/portkey/) > Portkey is an edge AI gateway managing API keys, rate limits, virtual keys, and request-level load balancing. NeoAI sits behind Portkey inside your VPC: it decomposes multi-step tasks, routes each sub-step to the cheapest model tier that passes your quality bar, and distils reviewer corrections into reusable workflow recipes. ## NeoAI and Portkey: How They Fit Together Engineering teams frequently ask whether NeoAI is an alternative to Portkey. The answer is that they address two entirely different layers of the enterprise AI stack and are designed to work together. Portkey operates at the network and API edge. It solves the critical operational problems of API key management, enterprise rate limiting, budget guardrails, fallback routing between model providers, and centralized request logging. However, when a complex prompt passes through Portkey, Portkey must route that entire request to a single target model (such as Claude 3.5 Sonnet or GPT-4o). Even if 80% of the work involved in that task is routine parsing and data extraction, the customer pays frontier pricing for every token. ## Where NeoAI Sits in the Pipeline NeoAI deploys inside the customer's private cloud VPC, directly behind Portkey or an equivalent gateway. In your Portkey configuration, you configure NeoAI as the upstream endpoint. When an incoming task arrives, NeoAI's lightweight planning agent decomposes the workload into a directed acyclic graph (DAG) of discrete steps. Simple structured extraction runs on small model tiers. Evaluative scoring runs on mid tiers. Only ambiguous judgment or costly edge cases run on frontier models. If an output fails a step-level rubric or schema check, NeoAI escalates that single step to a higher model tier automatically. The user and the calling application receive a verified result, never an unhandled error. ## Commercial Model: Gainshare vs SaaS Portkey charges traditional SaaS fees based on request volume and platform seats. NeoAI operates on a pure gainshare model: a free two-week audit measures your baseline spend and rework hours, followed by a pilot on your own evaluation set. If NeoAI does not measure verified savings on your workload, you pay no fee. ## Frequently Asked Questions ### Do I replace Portkey with NeoAI? No. NeoAI is designed to sit behind Portkey. You keep Portkey for API key governance, provider load balancing, and edge caching. In your app or Portkey config, you simply route upstream requests through NeoAI in your VPC. ### Why can't Portkey optimize step-level model costs? Portkey sees requests as atomic units passing through its gateway proxy. It cannot decompose an prompt into discrete sub-steps, run assertions against rubric gates, or escalate individual failed sub-steps without failing the whole request. ### How do the pricing models differ? Portkey charges per request or enterprise subscription for gateway infrastructure. NeoAI operates purely on gainshare: you pay a share of measured savings against a verified baseline on your own evaluation tasks. No savings, no fee. ## Canonical URL https://recipes.neoai.solutions/vs/portkey/ --- # NeoAI vs LiteLLM: API proxy standardization versus in-VPC workflow step delegation Published: 2026-10-25 | NeoAI (https://recipes.neoai.solutions/vs/litellm/) > LiteLLM provides a fast, lightweight proxy that unifies 100+ LLM APIs behind a single OpenAI-compatible interface with load balancing. NeoAI operates in your VPC behind LiteLLM to decompose tasks into discrete steps, route each sub-step across model tiers, and automate quality gates using recipes learned from your accepted runs. ## How NeoAI and LiteLLM Work Together LiteLLM has become an industry standard for unifying hundreds of LLM APIs behind an OpenAI-compatible interface. It solves the critical developer friction of managing heterogeneous SDKs, provider-specific payload schemas, and API rate limits. Where LiteLLM ends is where NeoAI begins. LiteLLM is fundamentally an API proxy: when your application sends a 4,000-token prompt asking to analyze an employment contract or summarize a financial filing, LiteLLM forwards that complete request to one model. Because frontier models cost roughly 20x small models per token, burning a model like Claude 3.5 Sonnet or GPT-4o on every token of a long document is economically unsustainable at scale. ## Decomposing Tasks into Multi-Tier DAGs By placing NeoAI behind your LiteLLM proxy, incoming requests are analyzed by a lightweight planning agent inside your VPC. NeoAI splits the work into a directed graph of sub-steps: - Data Extraction: Parsing tables, dates, and names runs on small, fast models (e.g. Claude Haiku or Gemini Flash-Lite). - Rubric Scoring: Bounded evaluation runs on mid-tier models with calibrated temperature. - Complex Synthesis: Edge-case reasoning and final judgment are delegated to frontier models only when necessary. Furthermore, NeoAI distils your human reviewers' edit history into automated assertion checks. If a small model's sub-step output fails an assertion, only that single sub-step escalates to a higher tier. ## Commercial Alignment LiteLLM is open source with optional enterprise support. NeoAI pairs seamlessly with your self-hosted LiteLLM deployment under a pure gainshare model: if our step-level delegation does not measurably reduce your net AI cost against your baseline evaluation set, you pay nothing. ## Frequently Asked Questions ### Can I use LiteLLM and NeoAI together? Yes. LiteLLM serves as your OpenAI-compatible interface and connection manager to providers (Bedrock, Vertex, OpenAI, Anthropic). NeoAI sits as the upstream target behind LiteLLM, handling task decomposition and quality gating in your VPC. ### Doesn't LiteLLM already have a router? LiteLLM has a router for request-level load balancing, cooldowns, and fallbacks (e.g. if Azure OpenAI is down, fallback to Anthropic). It routes the entire request to one model. NeoAI decomposes a single task into multiple sub-steps with varying model sizes and reasoning budgets. ### How does NeoAI handle model keys when using LiteLLM? NeoAI can either forward its delegated sub-step calls back through LiteLLM's proxy, or call model endpoints directly using your existing credentials. Your model provider relationships and volume discounts remain untouched. ## Canonical URL https://recipes.neoai.solutions/vs/litellm/ --- # NeoAI vs LLM Model Routers: Single-request routing versus step-level workflow delegation Published: 2026-10-25 | NeoAI (https://recipes.neoai.solutions/vs/martian/) > Per-request model routers like Martian and RouteLLM predict whether an entire prompt is hard or easy, then route the full request to either a small or frontier model. NeoAI operates at the sub-step level: it decomposes tasks into discrete steps so routine work runs on small models while reserving frontier reasoning for complex sub-steps. ## The Fundamental Problem with Per-Request Routers First-generation LLM routers operate on a simple premise: use a lightweight classifier to decide whether a user prompt is "simple" (send to a 7B or 8B model) or "hard" (send to GPT-4o or Claude Sonnet). While this approach works for conversational customer support queries, it fails on enterprise multi-step workloads. Real-world business tasks—such as processing insurance claims, evaluating financial statements, or analyzing software bugs—are inherently heterogeneous. In a typical document processing task, 80% to 90% of the token volume is spent extracting text, structuring JSON schemas, and formatting summaries. Only 10% to 20% involves complex judgment. A per-request router must classify the whole task as "hard", forcing you to pay frontier rates for all 4,000 tokens. ## How NeoAI Step-Level Delegation Solves This NeoAI operates inside your private VPC. Instead of treating the request as a monolithic black box, NeoAI splits the workload into an executable directed acyclic graph (DAG): - Extraction steps run on small, high-throughput models at a fraction of the cost. - Evaluation steps run on mid-tier models constrained by precise rubrics. - Frontier reasoning is engaged only for ambiguous edge cases or when automated step verification checks fail. On standard enterprise workloads, this fine-grained delegation reduces token spend by 55% to 85% compared to monolithic frontier execution, while matching or exceeding output quality. ## Beyond Routing: Rework and Retries Model routers are blind to what happens after an answer is delivered. If an output is subtly wrong, vague, or missing citations, a human staff member spends 20 minutes redlining the text or re-running prompts. NeoAI captures these human corrections and distils them into automated quality gates. By cutting both the cost per attempt and the number of attempts required to reach an accepted output, NeoAI scales company-wide throughput with existing headcount. ## Frequently Asked Questions ### Why isn't a per-request router enough for complex workflows? Most enterprise workflows are mixed: a 10-page document analysis has simple data extraction (cheap) and difficult legal reasoning (expensive). A per-request router must classify the whole task as hard and route 100% of the tokens to a frontier model. NeoAI decomposes the task so each sub-step runs on the cheapest sufficient tier. ### Does NeoAI require training router classifiers? No. Model routers often require fine-tuning custom routing classifiers or training embedding models on historical data. NeoAI uses explicit, interpretable task recipes with deterministic quality gates (schema tests, citation checks, score bounds) distilled directly from your reviewers' accepted work. ### How does recipe learning carry over between tasks? Model routers treat every prompt in isolation. NeoAI recipes are constructed from modular blocks (rubric scoring, evidence extraction, calibration). When you launch a related task, it reuses the proven blocks and begins with higher quality from day one. ## Canonical URL https://recipes.neoai.solutions/vs/martian/ --- # Security: your cloud, your data, your recipes Published: 2026-10-25 | NeoAI (https://recipes.neoai.solutions/security/) > NeoAI is designed to run in your own VPC, behind your existing AI gateway. Prompts never train anything for other customers, you own the recipes and can export them, and every recipe version is logged and auditable. A data processing agreement is available; SOC 2 and ISO 27001 status is still to be confirmed. ## What stays inside your boundary NeoAI, the recipe store, the evaluation harness and the audit log all run inside your cloud boundary. Your apps call your existing AI gateway, NeoAI sits behind it, and NeoAI calls your model providers. Adopting NeoAI adds no new data, integration or financial risk: it is one endpoint change, with no workflow change. ## Security and ownership commitments Status labels: Commitment means a design commitment that your security team can verify in the audit and pilot. Nothing here claims a certification NeoAI does not yet hold. | Area | What NeoAI commits to | Status | | --- | --- | --- | | Deployment | Runs in your VPC, behind your existing AI gateway | Commitment | | Data use | Prompts never train anything for other customers | Commitment | | Recipe ownership | Recipes are owned by you and exportable | Commitment | | Auditability | Every recipe version is logged and auditable | Commitment | | Reliability | Automatic fallback: a failed step escalates, and the user never sees an error | Commitment | | Data processing agreement | DPA available | Available | | SOC 2 / ISO 27001 | Certification plan to be shared with your security team | To be confirmed | ## How quality is protected before go-live Quality is tested before go-live on your own prompts against your acceptance criteria. The evaluation method is open to your team, so your engineers can inspect the evaluation set, the acceptance rules and the results rather than take a score on trust. See how the pilot is structured. ## Questions your security team will ask - Does data leave our cloud? NeoAI is designed so that it does not. Confirm the exact data flows with us in the audit. - Can we leave and keep what was learned? Yes: recipes are yours and exportable. - Can we see what changed and when? Yes: every recipe version is logged. - What certifications do you hold? The certification plan and status are still to be confirmed, and we will say so plainly in any security review. To start a security review, email contact@neoai.solutions or request the free audit. ## Frequently Asked Questions ### Where does NeoAI run? In your own VPC, behind your existing AI gateway. The recipe store, evaluation harness and audit log are inside your cloud boundary. ### Does NeoAI train models on our prompts? No. Prompts never train anything for other customers. ### Who owns the recipes NeoAI learns? You do. Recipes are owned by you and exportable, and every version is logged and auditable. ### Is NeoAI SOC 2 or ISO 27001 certified? Certification status is still to be confirmed. A data processing agreement is available. ## Canonical URL https://recipes.neoai.solutions/security/ --- # Pricing: you only pay from what we save you Published: 2026-10-25 | NeoAI (https://recipes.neoai.solutions/pricing/) > NeoAI is priced as a gainshare: a share of the savings it measures on your own tasks. The audit is free, the pilot is measured on your evaluation set, and if there are no measured savings, there is no fee. The share is [X]% of measured savings, to be set. ## How gainshare pricing works NeoAI takes a share of measured savings, set at [X]% Commercial. Your spend after NeoAI plus the savings you keep plus NeoAI's share together equal what you spent today. The share applies to the savings only, never to your whole spend. If NeoAI measures no savings, you pay no fee. The percentage is to be set. This page will state it as soon as it is fixed. A machine-readable version of this page is at /pricing.md. ## The three stages and what each costs you | Stage | Length | What happens | | --- | --- | --- | | 1. Audit (free) | About 2 weeks Commitment | We map where AI spend and rework go and size the savings on your data. | | 2. Pilot | 2–4 weeks Commitment | Recipes learned, delegation tuned, quality tested on your prompts against your acceptance criteria. | | 3. Roll-out | Ongoing | Monthly re-tuning as models and prices change. | Read what the audit covers and what we need from you. ## How savings are measured - Evaluation set. Real tasks from your work, with your acceptance criteria. - Baseline period. Your current setup runs the set and is measured. - NeoAI period. The same tasks run at the same quality bar. - Comparison. Cost per accepted task, attempts per task, staff hours on rework, first-pass acceptance and quality pass rate Pilot: to measure. Because the same tasks are held to the same quality bar, a cheaper result that fails your bar does not count as a saving. See cost per accepted task, the metric the comparison uses. ## What savings to expect Our savings estimator ranges from 55–70% lower spend for enterprise Q&A, 60–80% for engineering and 65–85% for agents Estimate. These are estimates, not results. A pilot replaces them with measured numbers on your work. NeoAI has no published customer results yet. ## Frequently Asked Questions ### How much does NeoAI cost? NeoAI is paid a share of the savings it measures on your own tasks. The audit is free. The share is [X]%, to be set. If there are no measured savings, there is no fee. ### What counts as a saving? The difference in cost per accepted task between a baseline period on your current setup and a NeoAI period on the same tasks at the same quality bar. ### What if NeoAI saves nothing? Then you pay no fee. No measured savings, no fee. ## Canonical URL https://recipes.neoai.solutions/pricing/ --- # Free AI spend audit: your own numbers in about 2 weeks Published: 2026-10-25 | NeoAI (https://recipes.neoai.solutions/audit/) > The NeoAI audit is free and takes about 2 weeks. We map where your AI spend and rework go today, identify which tasks have recipes worth learning, and size what you would save on your own data. You decide afterwards whether to run a 2 to 4 week pilot. ## What you get - Where spend and rework go today. Spend by workflow, attempts per task and where staff hours disappear into fixing and re-asking. - Which tasks have recipes worth learning. The repeated, high-volume tasks where a recipe would cut attempts. - What you would save, sized on your data. A range grounded in your usage, to be replaced by measured numbers if you run a pilot. - A one-page brief for your executives. Answers for the CEO, CTO, CIO and CFO, ready to forward. ## What we usually need from you - A usage export from your gateway or provider dashboard (model, tokens, cost, time, team or app). - A short list of the AI workflows people complain about or redo most. - One named contact, and a 20-minute intro call. We use your details only to follow up. Security questions are welcome from the first call: see what stays inside your cloud. ## What happens after the audit - Audit (about 2 weeks, free). Findings and a sized savings range. - Pilot (2–4 weeks). Run on your own evaluation set, with a baseline and a NeoAI period, so the result can be audited by your team. - Roll-out. Monthly re-tuning as models and prices change. Pricing is gainshare: no measured savings, no fee. ## Who the audit is for Heads of AI and VPs of Engineering at AI-native scale-ups and mid-market companies spending $20k–$500k a month on LLMs, and VPs and Directors of AI Platform at enterprises who need an answer they can forward to the CFO and CIO. If you spend well under $20k a month, a gateway may be all you need for now. ## Frequently Asked Questions ### How long does the AI spend audit take? About 2 weeks. ### Does the audit cost anything? No. The audit is free. ### What do I have to commit to by booking an audit? Nothing beyond an intro call and a usage export. You decide afterwards whether to run a pilot. ## Canonical URL https://recipes.neoai.solutions/audit/ --- # The LLM price gap: how much more a frontier model costs than a small one Published: 2026-10-25 | NeoAI (https://recipes.neoai.solutions/data/llm-price-gap/) > On published list prices read on 25 Oct 2026, a mid-priced frontier model costs about 20x a small model in the same family, and the top tier costs up to 100x the smallest. That gap is why running every step on the biggest model is expensive, and why it only pays to use a small model where it still meets your quality bar. ## List prices, per million tokens Prices are standard, non-batch, non-cached, in US dollars per million tokens (MTok), copied from each provider's pricing page on the date shown. Public list prices Sources: [Anthropic pricing](https://platform.claude.com/docs/en/about-claude/pricing), read 25 Oct 2026; [Gemini API pricing](https://ai.google.dev/gemini-api/docs/pricing), page updated 22 Oct 2026, read 25 Oct 2026. Haiku 5.5 is shown for prompts up to 100,000 tokens; above that it is $0.50 input and $2.50 output. Gemini 3.1 Pro Preview is shown for prompts up to 200,000 tokens. | Provider and model | Tier | Input $/MTok | Output $/MTok | | --- | --- | --- | --- | | Anthropic, Claude Fable 5.1 | Frontier | 10.00 | 50.00 | | Anthropic, Claude Opus 5.5 | Frontier | 4.00 | 20.00 | | Anthropic, Claude Sonnet 5.5 | Mid | 2.00 | 10.00 | | Anthropic, Claude Haiku 5.5 | Small | 0.10 | 0.50 | | Google, Gemini 3.1 Pro Preview | Frontier | 2.00 | 12.00 | | Google, Gemini 2.5 Flash | Mid | 0.30 | 2.50 | | Google, Gemini 2.5 Flash-Lite | Small | 0.10 | 0.40 | ## The ratio between tiers Ratios are computed from the table above. The gap depends on which two models you compare, so we state the pair each time. Public list prices | Comparison | Input | Output | | --- | --- | --- | | Claude Fable 5.1 vs Claude Haiku 5.5 | 100x | 100x | | Claude Opus 5.5 vs Claude Haiku 5.5 | 40x | 40x | | Claude Sonnet 5.5 vs Claude Haiku 5.5 | 20x | 20x | | Gemini 3.1 Pro Preview vs Gemini 2.5 Flash-Lite | 20x | 30x | | Gemini 3.1 Pro Preview vs Gemini 2.5 Flash | 6.7x | 4.8x | The figure we use elsewhere on this site, "about 20x", is the like-for-like gap between a strong general model and a small model in the same family. The top tier against the smallest tier is far larger. ## What the gap means for one step A worked example for a single step that sends 1 million input tokens and receives 200,000 output tokens. Worked example | Model | Input cost | Output cost | Total | | --- | --- | --- | --- | | Claude Fable 5.1 | $10.00 | $10.00 | $20.00 | | Claude Sonnet 5.5 | $2.00 | $2.00 | $4.00 | | Claude Haiku 5.5 | $0.10 | $0.10 | $0.20 | ## Why a price gap alone does not save money Price per token is not cost per task. A small model that fails your quality bar creates retries and staff rework that can cost more than the tokens saved. The saving only exists where the cheaper model still passes your acceptance criteria, which is why NeoAI scores each step for difficulty, escalates a step when a confidence check fails, and measures cost per accepted task rather than price per token. See how smart delegation works. ## Other levers on the same pricing pages - Batch processing. Anthropic's Batch API gives a 50 percent discount on both input and output tokens for work that can wait. Public list prices - Prompt caching. Cache reads are priced well below base input: Claude Haiku 5.5 $0.01 vs $0.10 and Claude Opus 5.5 $0.20 vs $4.00 per MTok. Public list prices - Promotional pricing. Some listed prices change on stated dates, so check the date before you rely on a figure. The full set of levers is in how to reduce LLM costs without lowering quality. ## Update policy We re-read these pages and refresh this table every quarter or when a provider changes a price, whichever comes first. Next scheduled review: January 2027. Spotted a stale number? Email contact@neoai.solutions. ## Frequently Asked Questions ### How much more does a frontier LLM cost than a small one? About 20x like for like within one family (Claude Sonnet 5.5 vs Claude Haiku 5.5, or Gemini 3.1 Pro Preview vs Gemini 2.5 Flash-Lite on input), and up to 100x between the top and smallest Claude tiers, on list prices read 25 Oct 2026. ### Where do these prices come from? Directly from the Anthropic and Google Gemini API pricing pages, read on 25 Oct 2026 and linked under the table. ### How often is this page updated? Quarterly, or sooner when a provider changes a price. Next scheduled review is January 2027. ## Canonical URL https://recipes.neoai.solutions/data/llm-price-gap/ --- # Simulated replay method: how we got 65–72% fewer tokens, and what it does not prove Published: 2026-10-25 | NeoAI (https://recipes.neoai.solutions/methodology/simulated-replay/) > We replayed three agent tasks step by step, counted tokens with tiktoken (o200k_base) and priced them at list prices, with no live model calls. The NeoAI-optimised run used 65–72% fewer tokens and cost 55–69% less. Quality was not measured, so this supports the method but is not proof of results. ## Results Date of run: 21 Oct 2026. Costs in US dollars per task. "Cache cold" means the system prompt and playbook are not yet cached; "cache warm" means an earlier run already cached them. Simulated Simulated: not live model calls, quality not measured. Provider prompt caching is modelled for both pipelines. | Task | Agent steps | Baseline cost | NeoAI, cache cold | NeoAI, cache warm | | --- | --- | --- | --- | --- | | Market-entry research brief | 10 → 7 | $0.0499 | $0.0189 (−62%) | $0.0155 (−69%) | | Bug fix in an unfamiliar codebase | 10 → 7 | $0.0489 | $0.0191 (−61%) | $0.0157 (−68%) | | Churn analysis memo from 3 data exports | 9 → 8 | $0.0470 | $0.0210 (−55%) | $0.0176 (−62%) | Total tokens per task (fresh input, cached input and output). Token counts are the same cold and warm. | Task | Baseline tokens | NeoAI tokens | Change | | --- | --- | --- | --- | | Market-entry research brief | 95,718 | 26,914 | −72% | | Bug fix in an unfamiliar codebase | 96,704 | 27,834 | −71% | | Churn analysis memo from 3 data exports | 91,428 | 32,319 | −65% | The optimised runs make more model calls than the baseline (12, 13 and 12 against 10, 10 and 9) because some steps run on a small model. They still use far fewer tokens, because the frontier model sees a shorter context. ## What was replayed Each task is a fixed trajectory of agent steps: a tool call or a model action, a tool output of a stated size, and a short piece of model reasoning. The replay builds the exact context each step would send, step by step, then counts the tokens. No model is called, and the text inside each tool output is synthetic filler, so only its length matters. - Market-entry research brief: choose two markets to enter first for a B2B data-labelling service. Searches, page fetches, a comparison in Python, and a written brief. - Bug fix in an unfamiliar codebase: find why a CSV export drops rows after 10,000 and make the tests pass. - Churn analysis memo: explain a Q3 churn rise from three data exports and recommend three actions. ## How the optimised run differs from the baseline - A short playbook of about 70 tokens is added to the system prompt, standing in for a recipe. In the replay it steers the agent away from steps marked as known dead ends, so those steps are skipped. - Simple steps go to a small model. A step marked as simple enough sees only the task and its own tool output, and returns a short distilled note instead of the raw output. - Shorter history. The frontier model's running history holds those distilled notes rather than full tool outputs. - The frontier model handles the rest. Judgment steps, such as the comparison and the final write-up, stay on the frontier tier. ## Assumptions and prices | Item | Value used | | --- | --- | | Tokenizer | tiktoken, o200k_base | | Frontier price (per million tokens) | $2.00 input, $0.10 cached input, $10.00 output | | Small price (per million tokens) | $0.10 input, $0.01 cached input, $0.50 output | | Price source and date | OpenAI standard list prices, 21 Oct 2026 | | System prompt and tool schemas | 1,682 tokens, identical in both runs | | Per-step reasoning | 120 words of model output | | Final deliverable | 350 words | | Tool output sizes | 200 to 2,500 words per step, stated per step | | Prompt caching | Applied to both pipelines once the unchanged prefix reaches 1,024 tokens | | Dead ends and simple steps | Marked by us per step. These are assumptions. | ## What this replay does not show - It does not measure quality. A cheaper run that gives a worse answer would look better here. Only a pilot measures quality pass rate. - The dead ends and simple steps are assumed, not discovered. The savings depend on a recipe that can really identify them on your tasks. - It is three tasks, not a sample of your workload. Your results will differ, in either direction. - It is not a customer result. NeoAI has no published customer results yet. That is why the pilot exists: a baseline and a NeoAI period on your own evaluation set, with quality measured against your acceptance criteria. The script and its raw output are available on request: email contact@neoai.solutions. ## Frequently Asked Questions ### Were real models called in the simulated replay? No. The replay builds the context each step would send and counts tokens with tiktoken (o200k_base). No model is called. ### Does the 65–72% token reduction mean quality stayed the same? No. Quality was not measured in the replay. Only a pilot on your own evaluation set measures quality pass rate. ### Why is the cost saving given as a range from 55% to 69%? The low end is with a cold prompt cache and the high end with a warm one. Both are shown in the results table. ## Canonical URL https://recipes.neoai.solutions/methodology/simulated-replay/ --- # How to reduce LLM costs without lowering quality Published: 2026-10-25 | NeoAI (https://recipes.neoai.solutions/guides/reduce-llm-costs/) > Reduce LLM costs by measuring cost per accepted task first, then cutting retries, matching each step to the cheapest model that passes your quality bar, trimming context, caching repeated prefixes, batching work that can wait, and gating quality with automatic escalation. Retries and model choice are usually the largest levers. ## Start with the right equation AI cost per task is people time plus attempts multiplied by cost per attempt. Most cost-cutting work only attacks cost per attempt, by switching to a cheaper model. That can raise the bill if the cheaper model needs more retries, because every retry costs tokens and staff time. Work through the levers below in order, and measure the result as cost per accepted task, not price per token. ## 1. Measure cost per accepted task Count, for each workflow, the model spend plus the staff time spent fixing and re-asking, divided by the outputs that passed your acceptance criteria. Without this number every other lever is a guess, and a cheaper model can look like a win while the true cost rises. Start with your top three workflows by spend. ## 2. Cut retries before you touch models If a task takes four or five attempts, the cheapest saving is the attempts you remove. Retries come from inconsistent prompts, missing context and no shared definition of "done". Capture how your best people get a task accepted first time, then reuse it for everyone. That is the idea behind NeoAI's distilled recipes. You can start by hand: write down the steps, context and checks for your five most repeated tasks. ## 3. Match each step to the cheapest model that passes Use a small model for routine steps such as parsing, extraction and drafting, and keep the frontier model for steps that need judgment. The prize is large: on list prices read on 25 Oct 2026, a mid-priced model costs about 20x a small model in the same family Public list prices. See the dated price table. Decide per step, not per application, and test each choice against your acceptance criteria, not an average benchmark. ## 4. Trim context Input tokens are billed on every call, and agents resend their whole history on each step. Send only the sections a step needs, summarise tool outputs before they enter the running history, and cap loops. In our simulated replay, shortening what the frontier model sees was a main reason token use fell 65–72% Simulated. That is a simulation, not a promised result. ## 5. Cache repeated prefixes System prompts, tool schemas and shared instructions repeat on every call, and providers bill cache reads at a fraction of base input. On Anthropic's list, Claude Haiku 5.5 cache reads are $0.01 per million tokens against $0.10 base, and Claude Opus 5.5 is $0.20 against $4.00 Public list prices. Keep stable content at the start of the prompt and variable content at the end so the prefix can be reused. ## 6. Batch work that can wait Anthropic's Batch API gives a 50 percent discount on both input and output tokens for asynchronous work Public list prices. Overnight classification, back-fills and evaluation runs rarely need a live answer. Move them to batch before optimising anything else on those workflows. ## 7. Gate quality, and escalate instead of failing Every saving above is only a saving if quality holds. Define acceptance criteria per task, run a fixed evaluation set before and after each change, and add a confidence or quality check on cheaper steps. When a cheap model is unsure, move that step up a tier automatically rather than returning an error or a poor answer. This is how NeoAI's smart delegation works. ## Common mistakes - Switching everything to the cheapest model. Retries and rework can cost more than the tokens saved. - Judging by an average benchmark. Your tasks and your acceptance criteria are what count. - Measuring spend, not outcomes. Falling spend with falling acceptance is not a saving. - Ignoring staff time. Hours spent fixing outputs are part of the cost. - Optimising once. Models and prices change, so re-tune on a schedule. ## Where a tool helps You can run levers 1, 4, 5 and 6 yourself. Levers 2, 3 and 7 are where it is hardest to do by hand, because they need recipes learned from your accepted work and a per-step decision with automatic escalation. If you spend $20k a month or more on LLMs, a free audit sizes what those levers are worth on your data. Pricing is gainshare: no measured savings, no fee. ## Frequently Asked Questions ### What is the fastest way to reduce LLM costs? Move work that can wait to batch processing and cache repeated prompt prefixes. Both are quick, and on Anthropic list prices batch is a 50 percent discount and cache reads cost a fraction of base input. ### Will switching to a cheaper model lower my bill? Only if the cheaper model still passes your quality bar. If it needs more retries, cost per accepted task can rise even though price per token falls. ### What is the biggest hidden cost in LLM spend? Retries and staff rework. Several attempts per task, and hours spent fixing and re-asking, often cost more than the token price difference between models. ## Canonical URL https://recipes.neoai.solutions/guides/reduce-llm-costs/ --- # Cost per accepted task: the LLM cost metric that price per token hides Published: 2026-10-25 | NeoAI (https://recipes.neoai.solutions/guides/cost-per-accepted-task/) > Cost per accepted task is the model spend plus the staff time spent on rework, divided by the number of outputs that passed your acceptance criteria. It measures what you pay for work that is actually done, so it exposes cost that price per token hides: retries, fixing and re-asking. ## Definition and formula Cost per accepted task = (model spend + rework staff time valued at a loaded hourly rate) ÷ accepted tasks, over the same period and workflow. An accepted task is an output that passed the acceptance criteria you set for that task type, whether by a person or an automatic check. It is the same equation as the cost model on the NeoAI overview, expressed per outcome: people time plus attempts times cost per attempt, divided by the number of accepted outputs. ## Why price per token misleads A cheaper model lowers cost per attempt. If it fails your bar more often, attempts and rework rise. The worked example below uses invented round numbers to show how the cheaper option can cost more per accepted task. Worked example Illustrative 100 tasks per week, staff time valued at $60 per hour. | | Option A: stronger model | Option B: cheaper model | | --- | --- | --- | | Attempts for 100 tasks | 380 | 520 | | Cost per attempt | $0.50 | $0.25 | | Model spend | $190 | $130 | | Rework time | 25 hours ($1,500) | 40 hours ($2,400) | | Total | $1,690 | $2,530 | | Cost per accepted task (100 accepted) | $16.90 | $25.30 | Option B halves the cost per attempt and still costs about 50% more per accepted task. The metric makes the trade-off visible. ## How to start measuring it - Pick one workflow with steady volume, such as resume screening, support triage or code review. - Write the acceptance criteria. What must be true for an output to count as done? Make it checkable. - Log attempts. Record each attempt, its model cost, and whether it was accepted, edited or sent back. - Estimate rework time. Sample a few tasks and time the fixing and re-asking, then apply a loaded hourly rate. - Divide. Total cost over accepted tasks, per week. Track the trend, not one week. ## Related measures - Attempts per task. The average number of tries before an output is accepted. Lower is better. - First-pass acceptance. The share of tasks accepted on the first attempt. - Quality pass rate. The share of outputs that meet the quality bar on an evaluation set. - Staff hours on rework. Time spent fixing and re-asking. These are the five measures NeoAI reports in a pilot Pilot: to measure. The gainshare fee is calculated from the change in cost per accepted task between a baseline period and a NeoAI period on the same tasks. ## Frequently Asked Questions ### What is cost per accepted task? Model spend plus staff time spent on rework, divided by the number of outputs that passed your acceptance criteria, over the same period and workflow. ### How is it different from cost per token? Cost per token ignores retries and rework. Cost per accepted task includes them, so it shows whether a cheaper model really saves money. ### Do I need special tooling to measure it? No. You can start with a log of attempts, their model cost and whether each was accepted, plus a sample of rework time for one workflow. ## Canonical URL https://recipes.neoai.solutions/guides/cost-per-accepted-task/ --- # Model cascading in AI agents: how to tier models and quality gates to cut spend 70% Published: 2026-10-25 | NeoAI (https://recipes.neoai.solutions/guides/model-cascading-agents/) > Model cascading is an architectural pattern where multi-step AI agents delegate routine sub-tasks to small models and escalate to frontier reasoning tiers only when automated verification gates fail. This reduces agent token spend by 55–80% while ensuring production outputs meet rigorous quality bars. ## The Economics of Monolithic Agent Calls Autonomous AI agents—whether implemented in LangGraph, AutoGen, CrewAI, or bespoke Python DAGs—often burn immense token volumes. When an agent is prompted with a high-level goal, developers frequently configure the entire loop to use a single flagship model like Claude 3.5 Sonnet or OpenAI o1. This creates a compounding economic trap: an agent running 8 iterations to research a company and summarize financial filings might consume 50,000 tokens per run. If every step runs on frontier rates, a single task costs several dollars. At enterprise scale (thousands of daily executions), costs spiral rapidly. ## The Three Principles of Model Cascading Model cascading solves this by treating an agent task not as a monolithic loop, but as a multi-tier pipeline with deterministic gates: - Right-Size the Initial Tier: Routine data extraction, JSON serialization, and preliminary summarization always start on small models (1/20th the token price). - Deterministic Assertion Gates: Every step output is evaluated before passing to the next node. Gates include schema validation, citation checks against source text, and bounds checks. - Localized Step Escalation: When an output fails an assertion, only the failed step is escalated to a higher model tier. Completed steps are preserved from cache. ## Distilling Reviewer Corrections into Code The hardest challenge in building reliable cascades is defining the quality gates. If the gates are too strict, everything escalates to frontier models. If they are too loose, bad outputs slip through to end users. This is where NeoAI's recipe distillation engine excels: by observing your team's historical accept/reject decisions and human reviewer redlines, NeoAI automatically derives the precise rules, checks, and model tier assignments that match your quality bar at the lowest possible cost. ## Frequently Asked Questions ### What is the difference between model routing and model cascading? Model routing chooses one model for an entire request before execution. Model cascading dynamically executes a multi-step workflow across multiple model tiers, using automated verification gates to escalate individual steps to higher tiers when needed. ### What types of quality gates work best for LLM cascades? Deterministic gates: Pydantic/JSON schema validation, regex assertion tests, verbatim source quote checks, and lightweight secondary verifier models comparing outputs against a rubric. ### Does model cascading increase overall latency? No. For 90%+ of standard tasks, small models complete sub-steps in under 300ms (far faster than frontier models). Total end-to-end task latency is often lower, even with occasional step escalation. ## Canonical URL https://recipes.neoai.solutions/guides/model-cascading-agents/ --- # About NeoAI Published: 2026-10-25 | NeoAI (https://recipes.neoai.solutions/about/) > NeoAI is software that captures how a company’s best people get AI work done and applies it to every task, so work comes back right the first time at the lowest cost that meets the quality bar. It runs in the customer’s own cloud, behind their existing AI gateway, and is priced from measured savings. ## What we do Companies pay frontier-model prices for work a cheaper model could do, and pay again when the same task takes four or five attempts. NeoAI learns from your accepted outputs, turns the shortest path into recipes, and gives every step the cheapest model and effort that meets your quality bar. Read how it works. ## What we believe - Know-how first, savings second. The main prize is getting your best practice onto every task. Lower AI spend follows. - Prove it on your work. Claims are tested in a measured pilot on an evaluation set your team can audit. - Label every number. Estimates, illustrations and simulations are marked as such. We do not present a simulated figure as a result. - Safe to adopt. No new data, integration or financial risk: it runs in your cloud, you own the recipes, and pricing is gainshare. ## Where we are today NeoAI has no published customer results yet. What we have is a simulated replay, whose method and limits are published, a dated table of public list prices, and a free audit that sizes savings on your own data. The first pilots will produce the first measured results, and we will publish what they show. ## Who is behind NeoAI [Founder names, roles and backgrounds to be added.] NeoAI is built by a team with a background in AI data and quality operations: measuring whether model output is good enough is the hard part of doing this safely. ## Contact Email contact@neoai.solutions, or request the free audit. Website: recipes.neoai.solutions. ## Frequently Asked Questions ### What is NeoAI? NeoAI is software that captures how a company’s best people get AI work done and applies it to every task, at the lowest cost that meets the quality bar. It runs in the customer’s own cloud behind their existing AI gateway. ### Who is NeoAI for? Heads of AI and VPs of Engineering at companies spending $20k–$500k a month on LLMs, and VPs and Directors of AI Platform at enterprises. ### Does NeoAI have customers yet? No customer results are published yet. Savings are measured per customer in a pilot. ## Canonical URL https://recipes.neoai.solutions/about/ --- ## Machine-Readable Pricing Specification (/pricing.md) # Pricing: NeoAI Last updated: 2026-10-25. Page version: https://recipes.neoai.solutions/pricing/ NeoAI is priced as a gainshare: a share of the savings it measures on the customer's own tasks. If there are no measured savings, there is no fee. ## Stages | Stage | Length | Cost to the customer | |---|---|---| | Audit | About 2 weeks | Free | | Pilot on the customer's own evaluation set | 2 to 4 weeks | Paid only from measured savings (gainshare) | | Roll-out with monthly re-tuning | Ongoing | Gainshare on measured savings | ## Gainshare - Fee: [X]% of measured savings (to be set). - Applies to the savings only, never to total spend. - Savings are measured as the change in cost per accepted task between a baseline period on the customer's current setup and a NeoAI period on the same tasks at the same quality bar. - No measured savings, no fee. ## Expected savings (Estimate, not results) - Enterprise Q&A: 55 to 70% lower spend (Estimate) - Engineering: 60 to 80% lower spend (Estimate) - Agents: 65 to 85% lower spend (Estimate) NeoAI has no published customer results yet. A pilot replaces these estimates with measured numbers. ## Who it is for Companies spending roughly $20k to $500k a month on LLMs, and enterprise AI platform teams. ## Links - Audit: https://recipes.neoai.solutions/audit/ - How it works: https://recipes.neoai.solutions/how-it-works/ - Contact: contact@neoai.solutions --- ## Machine-Readable Audit Intake Specification (/audit.md) # NeoAI Free Spend & Rework Audit — Agent & Evaluator Specification Last updated: 2026-10-25 Canonical URL: https://recipes.neoai.solutions/audit/ Markdown Mirror: https://recipes.neoai.solutions/audit/full.txt Format: Machine-readable intake and qualification specification for evaluators and autonomous buying agents. ## 1. Overview & Qualification Criteria - **Cost**: Free ($0) Commitment. - **Duration**: About 2 weeks Commitment. - **Target Organization**: Companies spending roughly $20k to $500k a month on LLM APIs, and enterprise AI platform teams experiencing high human reviewer rework or repeated task retries. - **Commitment**: Zero obligation. Following the audit, you decide whether to run a 2 to 4 week pilot on your own evaluation set. - **Pilot Commercial Model**: Gainshare ([X]% of measured savings, to be set). If there are no measured savings against your baseline on the same tasks at the same quality bar, there is no fee. ## 2. Audit Deliverables 1. **Spend & Rework Map**: Where model spend and reviewer hours disappear today (attempts per task, rework time, model tier mismatch). 2. **Recipe Feasibility Analysis**: Identification of repeated, high-volume tasks where a distilled recipe would cut attempts and automate quality gates. 3. **Sized Savings Range**: Empirical estimation of cost reduction (typically 55–85% token cost reduction, plus substantial staff hours saved from reduced rework). 4. **One-Page Executive Brief**: A tailored summary with answers for the CEO (strategic value), CTO (difference from gateway), CIO (security/VPC boundary), and CFO (ROI and downside protection). ## 3. Inputs Required from Customer 1. **Usage Export**: An export from your gateway or provider dashboard (model, input/output tokens, cost, latency, team/app identifier). No raw user PII or proprietary prompt contents required. 2. **Workflow Shortlist**: The 1–3 AI workflows team members complain about or redo most (e.g. document summarization, extraction, resume screening, code review, report synthesis). 3. **Named Contact & Kickoff**: One named engineering or AI platform lead for a 20-minute kickoff and findings walk-through. ## 4. Security & Architecture Boundaries - **VPC Deployment**: NeoAI deploys in your VPC (AWS, GCP, Azure) behind your existing AI gateway (Portkey, LiteLLM, Cloudflare AI Gateway, Kong, Envoy). - **One Endpoint Change**: In application code, only the upstream URL changes. - **Zero Cross-Customer Training**: Prompts never train anything for other customers. - **Customer Owns Recipes**: Distilled recipes, evaluation harnesses, and audit logs live in your cloud and are exportable in open JSON/YAML formats. Every version is logged and can be rolled back. - **Data Protection Agreement**: DPA available upon request. ## 5. Machine-Readable Intake Schema (for Autonomous Agents) Autonomous buying agents or programmatic dispatch tools may initiate this audit request by emailing `contact@neoai.solutions` with subject line: `[Audit Request] ` and the following JSON payload: ```json { "request_type": "free_audit", "organization": { "name": "", "domain": "", "headcount_range": "100-500 | 500-2000 | 2000+" }, "contact": { "name": "", "title": "", "email": "" }, "ai_infrastructure": { "current_monthly_spend_usd": "", "cloud_provider": "AWS | GCP | Azure | Multi-cloud", "gateway_in_use": "Portkey | LiteLLM | Cloudflare | Kong | Custom | Direct API", "primary_models": ["gpt-4o", "claude-3-5-sonnet", "o1", "gemini-1.5-pro", "other"] }, "target_workflows": [ { "name": "", "estimated_daily_tasks": 500, "current_pain_point": "High retry rate / expensive frontier model on simple extraction / manual rework" } ] } ``` ## 6. Links & Verification - Free Audit Page: https://recipes.neoai.solutions/audit/ - How NeoAI Works: https://recipes.neoai.solutions/how-it-works/ - Security & VPC Architecture: https://recipes.neoai.solutions/security/ - Pricing & Gainshare Terms: https://recipes.neoai.solutions/pricing/ - Contact: contact@neoai.solutions --- ## Master FAQ Compilation ### How do I reduce my LLM costs without lowering quality? Cut retries first, then right-size each step. NeoAI does both: recipes learned from your own accepted work reduce attempts per task, and each step gets the cheapest model and effort that passes your quality bar, with automatic escalation when a cheaper model is unsure. Read the full guide. ### How is NeoAI different from an AI gateway or router? Gateways and routers pick one model per request. NeoAI sits behind your gateway and tunes the model, reasoning effort, context and budget for each sub-step, using recipes learned from your own usage that carry over between related tasks. See the comparison. ### What is a distilled recipe? A recipe is the shortest path to an accepted output for one type of task: the steps, the context, the tools and the checks. NeoAI updates it after every run, and a recipe earns its place only by passing your quality bar in the fewest attempts on real tasks. How recipes work. ### Where does NeoAI run, and who owns the recipes? NeoAI deploys in your VPC, behind your existing AI gateway, with one endpoint change. Prompts never train anything for other customers. You own the recipes, they are exportable, and every version is logged. Security details. ### How does gainshare pricing work? You pay a share of the savings NeoAI measures against a baseline on your own tasks. If there are no measured savings, there is no fee. The share is [X]%, to be set. Pricing details. ### What happens if a cheaper model fails? The step escalates to a higher tier automatically when it fails a confidence or quality check, so the user gets a result, never an error. ### How long are the audit and the pilot? The audit takes about 2 weeks and is free. The pilot runs 2 to 4 weeks on your own evaluation set. Roll-out follows, with monthly re-tuning as models and prices change. What the audit covers. ### What results has NeoAI measured so far? No customer results are published yet. In a simulated replay of three agent tasks, token use fell 65–72% and cost fell 55–69% (62–69% with a warm cache). Those were not live model calls and quality was not measured. Savings are measured per customer in a pilot. Read the method.