The agent that
remembers.
One Global Intelligence Layer
Agents have
amnesia.
Every session starts from nothing. The same files re-read, the same architecture re-derived, the same call run again at full price for an answer that never changed.
Context rebuilt from zero on every run.
The same call, billed twice.
A crawl mid-turn: latency, unranked pages.
Five bills to ship
one agent.
Every box is a contract, an SDK and a failure mode. Incord is the other side of the arrow.
- +Memory is native, not a plugin
- +Retrieval is pre-ranked, not a crawl
- +Voice carries user context from the first second
- +Inference passed through at cost, 0% markup
- +One key, one bill, one support surface
Agents are the
fastest-growing layer.
to 2030
Five houses, five methodologies, one direction. The band is the spread between the lowest and highest published forecast.
Every part we ship
is its own market.
A bundle's case is the sum of the markets it replaces. Each bar is a published 2030 forecast for one thing Incord already does.
MarketsandMarkets · BCC Research · The Business Research Company · Research and Markets · MarkNtel Advisors
Three regions,
three reasons.
Adoption is uneven and the reason to buy differs in each, which is why one product with a self-hosting option reaches all three.
The largest share of revenue today, and where buyers already run assembled stacks they are paying five times for.
The highest growth rate of any region. Greenfield deployments, fewer legacy contracts to unpick, and voice-first products.
Slower to adopt, stricter on where data sits — which is where self-hosting and a sealed team lane stop being features and become the requirement.
The agent stops starting from zero
Sessions and code edits are captured as they happen, embedded, linked into a scoped graph and ranked, so the answer is already at the top before anyone searches for it.
- Scoped by project, user, company and agent. An agent working in one repo searches one graph, not all thirty. That keeps retrieval fast as you grow, and it is an isolation guarantee at the same time.
- Ranked, not merely stored. Reciprocal rank fusion, personalised PageRank, keyword and a cross-encoder rerank decide what surfaces. Ranking ahead of time is what removes the search.
- Repeats are recognised. Tool calls are recorded with their results; a call whose answer has never changed is replayed instead of re-run.
- It hands off before the window fills. When context runs out, memory saves and hands over automatically. No compaction to manage, no rebuild to pay for, and a four-hour run does not lose what it learned in hour one.
- Any agent can use it. 33 tools over MCP, so it works with existing clients without a rewrite.
It knows your business, not just your prompts
Memory is only worth what reaches it. Your own databases, mailbox, code host and social accounts sync into the graph continuously, so agents answer from your records instead of what someone remembered to paste in.
- Live business data. Customers, orders, balances and subscriptions sync from your own Postgres, MySQL or SQLite into the same ranked graph everything else lives in.
- Any account, by configuration. Connectors are not a fixed vendor list. Any OAuth2 service is registered by config, so mail, code hosts and social accounts connect without waiting for us to ship support.
- The team shares one memory. Members sync peer to peer over a sealed lane with its own key ring, so a team gets a shared brain without a central pool holding everyone's data.
- Which is what makes an agent useful. A support agent that already has the customer's plan and history. A writer that has read everything you have published. A coding agent that knows this repository.
The world, embedded before you ask
A heartbeat pulls markets, news and events on a five-minute to daily cycle, embeds them in-process and tiers them hot to cold. Agents read a prepared index instead of firing a crawl mid-conversation.
- No search on the critical path. Retrieval replaces crawl-at-ask, which is where the seconds and the unranked noise come from.
- Six filter dimensions. Source, time, entity, domain, asset class and freshness, with cross-encoder reranking over the result.
- Spike and trend detection. A rolling per-entity signal buffer surfaces movement as it forms rather than after it is priced in.
- Validated before served. Facts are confirmed across sources, so a single bad feed does not quietly become a decision.
We don't tax your tokens
One endpoint reaches 150+ models and passes inference through at cost. You pay exactly the provider's token price, with no percentage skimmed and no per-request fee.
- It picks the model for you. The router selects the cheapest model that can actually do the task and escalates only when the task needs more. Choosing well is the saving, before a single token is discounted.
- Manthan, for the hard questions. A grounded multi-model fusion mode: several models answer, a judge compares them, and one best answer is assembled. The strongest setting for research.
- Context arrives already attached. Relevant knowledge and memory are injected before the prompt is sent, so there is no retrieval plumbing between you and the model.
- One key, no lock-in. The shape is OpenAI-compatible, so switching provider is a base URL rather than an integration.
A coding agent that keeps working
An approved roadmap becomes a work queue it advances on its own, writing code, reviewing it and escalating anything irreversible rather than stopping to ask what it was already told.
- It runs on the subscription you already pay for. It holds no API credential of its own, so there is no second inference bill and your code never leaves your machine to get a decision made about it.
- It delegates to stay cheap. Routine work goes to a small model and judgement to a strong one, using the same routing logic that runs the platform.
- It remembers the project. Scoped memory means it knows this codebase, rather than being a general assistant reading it fresh every session.
- A reviewer that argues back. A second model reviews the work, the coder can dispute a finding, and any file touched after a finding is re-checked rather than trusted.
Autonomy you can actually leave running
The blocker on unattended agents is not capability, it is that you cannot predict step forty. Five controls sit between the agent and anything that matters, and the last one is your phone.
- Guards stop the decision before it executes. Checked at the moment of the action, not suggested in a prompt the model may choose to ignore.
- Rules arrive at process time. Injected as the agent is about to act, so the instruction is in front of it exactly when it matters instead of buried at the top of a long session.
- The proxy answers for you. It holds your product context and settles routine decisions up to a severity ceiling you set, so the agent stops asking what it has already been told.
- The auditor reviews live code. It opens an argument with the coder rather than filing a note, and re-checks any file modified after a finding was raised.
- The owner app is the last gate. Anything irreversible escalates to your phone and waits. If the phone is unreachable it keeps waiting: approval fails closed, never open.
A voice agent that already knows the caller
Pure WebRTC, dropped into a web or mobile app. No phone numbers, no SIP trunks, no telecom markup, and the agent has native access to the memory of the person speaking from the first second.
- The stack is already assembled. Speech in, model, speech out, plus knowledge and memory: one endpoint instead of an orchestrator wired to four other vendors.
- No number, no trunk, no per-minute markup. Numberless WebRTC removes the telephony layer other platforms resell back to you.
- It remembers across channels. What the voice agent learns, the chat agent knows. Same graph, tied to the user rather than the app.
- Grounded in current fact. The same call reaches the live index, so the answer is not last quarter's.
Everyone stores.
We rank, scope and hand off.
Storing what was said is the easy half. The column on the right is what a memory has to do before an agent can be left alone with it.
| Capability | A memory library | Incord |
|---|---|---|
| Remembers across sessions | Yes | Yes |
| Scoped per project, team and agent | Per user or session | Four levels of scope |
| Hands off when context fills | You manage compaction | Automatic |
| Repeated tool calls | Paid for every time | Replayed, not re-run |
| Your business records | You build the pipeline | Live database sync |
| Team sharing | A central store holds it | Sealed peer-to-peer |
| Ranking | Similarity search | Fusion, PageRank, rerank |
| Guards on what an agent may do | Not in scope | Enforced before execution |
| Runs offline / self-hosted | Hosted API | Yes |
Nobody needs a frontier model
to name a capital city.
Ask the largest model on the market what the capital of France is and it answers correctly, slowly, and at hundreds of times the price of a model that answers it just as correctly.
- Every model publishes price and capability. The catalogue carries input and output cost per million tokens, context length, and what each model can actually do — tools, reasoning, structured output.
- The task is matched against that, not against a default. Naming a capital city and refactoring a codebase are not the same job, and they should not reach the same model.
- It escalates when the task earns it. Depth is bought where depth is needed. The saving is not a discount, it is not overpaying for questions that were never hard.
The same question,
priced three ways.
An aggregator resells you tokens at a markup and still lets you send everything to one model. This one matches the task, attaches the context, and adds nothing to the provider's price.
| What you need | Direct or aggregator | Incord |
|---|---|---|
| Reach every model | One key per provider | One key, 150+ models |
| Price | Provider price plus a fee | Provider price, 0% added |
| Choosing the model | You hard-code one for everything | Matched per task |
| A question a small model answers well | Billed at frontier rates | Routed to the small model |
| A question that genuinely needs depth | Same model as the easy one | Escalated on capability |
| Hard questions | One model, one answer | Several models, judged |
| Getting context in | You build retrieval | Injected before the prompt |
| Switching provider | An integration change | A base URL |
One plug.
One bill.
Install once — a terminal app, or straight into the agent client you already use — and every capability is present on the first call.
- One plug Install once — as a terminal app or into an agent client you already use — and every capability is present. No SDK per vendor, no glue to maintain.
- One bill Knowledge, memory, routing, agents and voice on a single invoice, with inference passed through at cost rather than marked up.
- Easy to start An OpenAI-compatible shape means migration is a base URL, not a rewrite. A free tier means the first call costs nothing.
- One call, every kind of agent Chat, voice, automation and code all reach the same endpoint and the same memory, so what one learns the others know.
- It saves the bill it sits on Repeated tool calls are replayed rather than re-run, context is recalled rather than rebuilt, and routine work is routed to a cheaper model.
The same agent,
minus four contracts.
| Speech in / speech out | Voice platform | Included |
| Model access | Bring your own key, or pay a markup | 150+ at cost, matched to task |
| Knowledge the agent answers from | Separate search API | Pre-embedded index |
| Memory of the caller | Memory vendor + vector DB | Native, tied to the user |
| Phone numbers and trunks | Telecom markup per minute | Not required, WebRTC |
| Context across chat and voice | You build the bridge | One graph, both channels |
| Contracts to sign | Five | One |
We don't tax
your tokens.
Inference is passed through at the provider's own price. The saving is buying fewer tokens: routing to the smallest model that works, and recalling what is already known.
Routine work to a small model, judgement to a strong one.
Known answers replayed rather than bought a second time.
One worked example: 400 tasks/month at $0.90, 70% routine, 35% already known. A model, not a published benchmark.
Not a library.
A system.
A desktop console over the graph, and an owner app in your pocket for whatever needs a human.
Not a demo.
A year of use.
Duration is the honest unit. Each part is listed with how long it has actually run and against what — including the one that has not started.
What the index
already holds.
Three months of continuous ingestion. This is the material an agent answers from without ever opening a browser.
100 crypto assets, equities, F&O, commodities, global indices and forex.
Over 1,000 US companies with filings and closing data.
Rust, Go, Node, C and others — documentation and changelogs, not just source.
Product information and review content.
Papers and long-form technical material.
What comes
after the layer.
Two lines of research, both marked as research. Neither is sold today, and neither is presented as if it were.
A company downloads any open-weight model, then trains against its own memory graph and client data with a LoRA on top. The result is a small private model that knows the business, without the business leaving it.
A workflow language whose first target is a web interface with auth. The agent does not reason about the task, it executes a defined one — which is drastically cheaper, because intelligence is only spent where the work is genuinely novel.
What runs today.
| Memory | Live | Running continuously; 218 MB accumulated across roughly thirty projects, serving recall, capture and the tool recorder. |
| Scoped isolation | Live | Enforced on the query path. Every recall returns its scope, and one project's agent cannot read another's graph. |
| Guards, rules and approval | Live | Rules are injected as an agent acts and guards gate the call itself; irreversible actions escalate to the owner app and fail closed. |
| Watchman recorder | Live | Returns a solved-task table per project and serves a recorded result instead of re-running the call. |
| Model router | Built | Public catalogue of 150+ models served from the gateway with per-token pricing published, but no trial period behind it yet — the only part of the platform not exercised in daily use. |
| Brain ingest and retrieval | Built | Heartbeat, tiering, six-dimension filtering and reranking implemented; 431 tests across graph and brain. |
| Voice | Built | WebRTC session endpoints plus speech and transcription, with TURN infrastructure running in production. |
| Team sync | Live | Peer-to-peer lane with enrolment, a sealed envelope key ring and a sync loop. No central pool holds the team's data. |
| Data connectors | Live | Live sync from customer databases, plus OAuth2 accounts registered by configuration rather than a fixed vendor list. |
| Published cost benchmark | Open | The reproducible side-by-side is not yet published, so no percentage appears on this page. |
Where this
goes next.
The platform is built and memory is load-bearing in daily use. Capital buys proof and reach: the published benchmark, voice in front of teams replacing a stack, and the agent on work that is not our own.
Amount, stage and instrument.
Users, pipeline, revenue or letters of intent.
Names, backgrounds, and what each person owns.
Allocation across benchmark, voice go-to-market and hiring.
Use ← → to move.