Smarter, faster agents. Needlepath sends your model only what matters.
Agents slow down and make mistakes when every step carries everything. Needlepath keeps the evidence the step needs, in your own words, before every model call.
Keep your model. Change one call. Pay as you go.
Every step reads everything, and pays for it.
Each tool call, document, memory read and workflow step adds to the context. The next model call reads all of it: more tokens, more time, and more chances to act on the wrong detail. The usual fixes each cost something too.
Attention gets diluted
Every extra page costs input tokens and competes for the model's attention, whether or not it helps this step.
Details go missing
A summary fits nicely, and can leave out the exact name, amount or order detail the next step needs, without saying so.
You own a system
Chunking, tuning and evals that drift every time the corpus changes, on someone's on-call rotation.
When the whole file is what the moment needs, it hands over the whole file. It decides in milliseconds, with no second model in the loop, and every response lists what was sent and what was left out.
Better answers at half the tokens, on a public benchmark.
Scored on the NVIDIA RULER benchmark, 2,600 questions, one run, official scorer, against sending everything.
- 1Answers were +12.9 pp better than sending the full document.
- 2Answering was 504 ms faster at p95 with Needlepath in the stack, end to end. The decision itself took 25.0 ms on average.
- 352.9% fewer input tokens were sent, counting the 24.0% of calls that received the complete document.
- 4The bill was 44.31% lower all in: $38.44 with Needlepath vs $69.02 sending everything, our fee included.
- 5Other preparation methods, measured on the same items, took 1.13 to 32.4 s per item in selection latency alone, some needing a GPU.
Read the detailed RULER results comparison
Estimate your savings here, or request a workload review and we measure the real share on your traffic. Starting point: the cost calculator's example month and the public test's 52.9%, counting the 24.0% of calls that received the complete document.
One call before every model call.
Send what you hold
Documents, tool results, chat history, memory, workflow state. Send the records as they are, with the question the model is about to answer.
Needlepath picks
Needlepath returns the records most relevant to the question, in milliseconds.
The model gets what matters
Your originals, unrewritten. When the whole set is what the question needs, the whole set goes through unchanged.
Copy, paste, run.
One key, one call before your model call, and a dashboard to watch it. The code below is the same as the docs; swap in your records and your prompt.
- 1Sign up and get an API key
Sign up for public beta today. The key is minted in the console and lives in your environment as
NEEDLEPATH_API_KEY. - 2Send your records and your prompt, get the context back, call your modelpip install needlepath
import os from needlepath import NeedlepathClient, ContextRecord, TaskSpec from openai import OpenAI client = NeedlepathClient(api_key=os.environ["NEEDLEPATH_API_KEY"], operating_point="np-2026-08-r4") # One record per item the agent holds: purchase orders, the supplier contract, the conversation so far. records = [ContextRecord(text=po.text, kind="external_data", id=po.id, title=po.title) for po in purchase_orders] prompt = "Which Corvane Freight purchase orders are still open past their delivery date?" result = client.select(records=records, task=TaskSpec(prompt=prompt), max_context_tokens=4000) context = result.rendered_context if result.applied else "\n\n".join(r.text for r in records) # Your model call, unchanged, with the context ahead of the prompt. answer = OpenAI().chat.completions.create( model="your-model", messages=[{"role": "user", "content": f"{context}\n\n{prompt}"}] )npm install @nextmoca/needlepath-sdkimport { NeedlepathClient } from "@nextmoca/needlepath-sdk"; import OpenAI from "openai"; const client = new NeedlepathClient({ apiKey: process.env.NEEDLEPATH_API_KEY!, operatingPoint: "np-2026-08-r4" }); // One record per item the agent holds: purchase orders, the supplier contract, the conversation so far. const records = purchaseOrders.map((po) => ({ text: po.text, kind: "external_data", id: po.id, title: po.title })); const prompt = "Which Corvane Freight purchase orders are still open past their delivery date?"; const result = await client.select({ records, task: { prompt }, maxContextTokens: 4000 }); const context = result.applied ? result.response!.renderedContext : records.map((r) => r.text).join("\n\n"); // Your model call, unchanged, with the context ahead of the prompt. const answer = await new OpenAI().chat.completions.create({ model: "your-model", messages: [{ role: "user", content: `${context}\n\n${prompt}` }], });pip install needlepath-langchainfrom langchain.agents import create_agent from needlepath_langchain import NeedlepathMiddleware # NEEDLEPATH_API_KEY is read from the environment. Nothing else in the agent changes. agent = create_agent(model, tools, middleware=[NeedlepathMiddleware(operating_point="np-2026-08-r4")]) answer = agent.invoke({"messages": [("user", "Which Corvane Freight purchase orders are still open past their delivery date?")]})pip install needlepath-litellm# config.yaml: every client behind the proxy gets selection, with no client-side change. guardrails: - guardrail_name: "needlepath" litellm_params: guardrail: needlepath_litellm.NeedlepathGuardrail mode: "pre_call" default_on: true operating_point: "np-2026-08-r4" history_max_tokens: 8000 preserve_recent: 2 # export NEEDLEPATH_API_KEY="np_live_..." in the proxy's environment, then: litellm --config config.yamlexport NEEDLEPATH_API_KEY="np_live_..."# One record per item the agent holds. Use rendered_context from the response ahead of the prompt. curl https://api.nextmoca.com/v1/context/select \ -H "Authorization: Bearer $NEEDLEPATH_API_KEY" -H "Content-Type: application/json" \ -d '{ "records": [ { "id": "po-2026-0412", "kind": "external_data", "title": "PO 2026-0412, Corvane Freight", "text": "..." }, { "id": "contract-corvane", "kind": "external_data", "title": "Corvane Freight delivery terms", "text": "..." } ], "task": { "prompt": "Which Corvane Freight purchase orders are still open past their delivery date?" }, "budget": { "max_context_tokens": 4000, "operating_point": "np-2026-08-r4" }, "render": true }' - 3Watch it work
Requests, tokens metered and tokens saved, per key, in the console. When Needlepath stands aside, the whole set goes through unchanged.
Full clients, the LlamaIndex integration and the rules every integration follows: docs.nextmoca.com/integrations.
In our cloud, or inside yours.
Start hosted in an afternoon, or keep everything inside your network. Same engine, same results, your call.
Drop in. One API key.
Install the client, point it at your workload, and Needlepath prepares the context before every model call.
- TypeScript and Python clients
- Context selection in milliseconds
- Shadow mode first: zero-risk evaluation
Or review your workload first.
Runs where your data lives.
Deployed into your VPC or data center, next to your models, and tuned for your workloads.
- Everything in hosted, plus
- Your records never leave your network, so data residency, retention and regulatory requirements are met where they already are
- Higher throughput with lower latency
- Dedicated support
Prefer to talk first? Book a 30-minute call
Integrates seamlessly with your existing tech stack.
Each integration runs one step before the call you already make, so nothing in your agent code changes to use it. When Needlepath stands aside, it returns your original context unchanged, and your call proceeds exactly as before, the same way on every integration.
Not on the list? Needlepath is three REST endpoints. Explore the API
The rest of the agent stack, built to the same standard.
The same public exam, task by task.
Each measured against sending everything.
Hyperscale operators and engineers who built and shipped agentic infrastructure at billion-dollar revenue scale. We are building Next Moca because we know what the next ten years of enterprise AI actually need.

Repeat builder. Co-founded and served as CTO of Green Piñata Toys (acquired). Director of Engineering at Oracle (OCI) and Brightcove, with prior leadership roles at Juniper, Cisco, and others. Built and scaled world-scale services for customers like ByteDance and HBO. Architect behind Next Moca's agentic orchestration and infrastructure layers. MBA (Babson), M.S. Computer Science (Penn State), B.E. Computer Engineering (University of Mumbai).

Product-driven inventor with a track record of bootstrapping new products, blending deep engineering with go-to-market focus. Director of Product at Adobe, with prior leadership roles at Microsoft, Oracle, and others. Holds multiple patents in distributed systems. Architect behind Next Moca's agentic foundations and core AI services. Executive MBA (Michigan Ross), M.S. Computer Science (USC), B.E. Computer Engineering (University of Mumbai).

Engineering and UX leader with 25+ years at Sun Microsystems and Oracle. Founding Member of Technical Staff at Next Moca, leading Agent Experiences. Expertise in UI/UX architecture, data security, and full-stack engineering.
Operators who built and shipped enterprise platforms at billion-dollar scale. They're betting on Next Moca because they've lived the problem we're solving.

Ran product and strategy at Brightcove (CPO) and Ellucian (CPO) over two decades of enterprise SaaS leadership. Now Managing Partner at ND Labs and lead investor in Next Moca.

Head of ML Platform at Capital One, operating production AI infrastructure for one of the largest regulated U.S. banks. Ph.D. in EECS from UC Berkeley, M.S. from UIUC, and B.Tech. from IIT Bombay.
Five answers before you decide.
What does Needlepath do?
Needlepath decides what enters each model call. Send the records your agent holds with the question the model is about to answer, and it returns the ones the step needs, unrewritten, in milliseconds. When the whole set is what the question needs, the whole set goes through unchanged.
How much does Needlepath save?
On the NVIDIA RULER benchmark, 2,600 questions, the bill was 44.31% lower all in with our fee included, with 52.9% fewer input tokens sent, counting the 24.0% of calls that received the complete document. Answers were +12.9 pp better than sending everything.
Does it rewrite or summarize my documents?
No. Needlepath sends your own records, unrewritten, and only the ones that answer the question. It does not summarize, compress or rerank the content of a record.
What happens when the whole file is what the question needs?
It hands over the whole file. When a smaller context cannot be shown to be safe, the complete document goes through unchanged, so what you risk on that call is paying full price.
How do I start?
Sign up for the public beta, create an API key, and add one call before each model call with the Python or TypeScript client. Keep your model. Pay as you go. Or request a workload review and we compare answer quality, token use, latency and cost on your own traffic.
Try Needlepath on your own workload.
Keep your model. Change the endpoint. Compare answer quality, token use, latency and cost on your traffic. Tell us what you are building and we reply within one business day. No commitment.
Thanks. Expect us to get in touch soon.
In the meantime, you can also reach us directly at kiran@nextmoca.com or swanand@nextmoca.com.
Your research access: the benchmark deep-dive, with the full scoreboard, per-length results, and method notes.
Prefer to talk first? Book a 30-minute call. Already decided? Sign up for public beta today.
kiran@nextmoca.com · swanand@nextmoca.com · Boston, MA · Palo Alto, CA