The answer engine
for agents and the businesses they read.
One live-web index, two directions. It grounds AI agents and private models — search, cited answers, deep research, standing monitors, all typed as data your model can act on. And it makes brands retrievable by the answer engines writing the new front page — measuring not just whether AI names you but whether it can reach you at all, then proving every citation against your own server logs. Visibility you can act on, and verify.
01 / 08
of web traffic is now automated — agents crossed the majority in 2026, 18 months ahead of forecast.
Cloudflare Radar, 2026
faster than humans: agentic AI traffic grew roughly 7,851% year over year.
HUMAN Security, 2026
of bot activity now targets APIs directly — machines skipping the human UI entirely.
Imperva Bad Bot Report, 2026
02 / 08
The same index reads the web for your agents — and gets your business read back to everyone else's.
Answer engines are the new interface to the web. Ipnops sits on both sides of that shift from one live-web index: grounding the models that ask the questions, and making the businesses that answer them citable. Pick the side you're on.
Grounding
Search, cited answers, async deep research, and standing monitors — typed as data your model can act on, over a live-web index that reaches past bot walls. One MCP endpoint or plain HTTP grounds any agent, including local and air-gapped models with no web access of their own.
- ▸POST /search · /answer · /research · /monitor
- ▸claim-level citations + calibrated confidence
- ▸grounding for private & sovereign AI
AI Discovery
Get retrieved by the AI answers that are the new front page. Ipnops observes which AI crawlers actually hit your site, scores retrieval readiness across nine engines — Western and Chinese frontier — enriches your real page with the levers that make it citable, and credits you when Ipnops itself cites you in an answer.
- ▸observe real AI-crawler hits · score 9 engines
- ▸structured data + server-render + crawler access
- ▸surfaced-in-answer attribution + analytics
03 / 08
An engine that reads the web, so your agent doesn't have to guess.
Retrieval built for people fails agents in a specific way: hallucinated citations, dead links, and confident answers when the source came back empty. Ipnops closes that gap at retrieval time — every answer is decomposed into claims, every claim is verified against the passage it cites, and when the evidence isn't enough, the response says so rather than guess.
One live-web index
The index stores structured passage chunks with claim provenance — hybrid-retrieved and reranked, kept current as the web moves — so every answer traces to a passage rather than a guess.
Claims, not prose
Every assertion arrives as data: the claim, its verdict, the literal quote behind it, and one calibrated confidence for the whole answer. An agent decides to trust, verify, or escalate — without re-parsing prose.
Grounded or it abstains
A verification pass grades every claim against its cited passage. Conflicting sources are surfaced and attributed, never averaged. And when the evidence doesn't cover the question, the answer reports insufficient instead of improvising.
04 / 08
The web is closing to machines. Ipnops still gets in.
APIs get metered, then walled. Bot detection blocks the crawlers every other engine depends on — the coverage they were built on is quietly disappearing. Ipnops answers with a ladder of reach: cheap rungs first — the live-web index, place data — and when a target hard-blocks, it escalates to a real browser that reads the page like a person. Every rung is grounding-checked, so a miss degrades cleanly to the next instead of guessing.
Cheap rungs first
Most questions never need a browser. A query resolves against the live-web index; anything spatial resolves through OSM/Nominatim place data. Each tier is grounding-checked, so a miss degrades cleanly to the next rung — the expensive path only runs when the cheap ones can't.
When it's blocked, it operates
Bot walls, logins, canvas apps, no-API surfaces — the data increasingly lives where a crawler can't follow. So Ipnops stops being a crawler: it drives a real browser through a plan → act → reflect loop, reading the page as a person would, and works the pixels with computer-use when the DOM lies. It doesn't evade detection — it isn't a bot to detect.
Ground once, replay forever
Grounding a fact usually means running the whole loop again on every request. Ipnops grounds a trajectory once, then replays it deterministically — turning O(steps × runs) model calls into O(1) on repeat work, so a warm path costs almost nothing to keep fresh.
05 / 08
Human search ends at the results page. Agent search is just getting started.
Classic engines live by one contract: answer in milliseconds or die. Agents don't need fast guesses — they need finished work. Ipnops runs searches that outlive the request: deep research that crawls what it's missing, and standing queries that watch a fact and call back when it changes.
Deep research as a durable run
One POST returns a run id. The engine answers, finds the claims it couldn't ground, crawls the gap, and re-answers — iterating until the answer holds or the budget is spent. Poll it, stream progress over SSE, or take a webhook when it closes. The run survives restarts; the index keeps what it learned.
Standing queries that watch the facts
Register a question once. Ipnops re-answers on schedule and diffs the grounded claims — a deterministic set comparison, zero extra model calls. Your webhook fires when the facts change, not when the phrasing does. Rewording is silence; a new number is a signal.
06 / 08
An MCP server, or plain HTTP. One line either way.
Point an MCP-native runtime at Ipnops and grounded search, answers, deep research, and monitors appear as typed tools — no SDK, no glue. Not on MCP yet? The same engine answers over plain HTTP. Either way the payload is model-shaped on arrival.
# one connector — Ipnops becomes an agent tool
{
"ipnops": {
"transport": "http",
"url": "https://api.ipnops.ai/mcp"
}
}# same call an agent makes over MCP — here as raw HTTP
curl -sS https://api.ipnops.ai/answer \
-H "content-type: application/json" \
-d '{ "query": "who maintains the sqlite file format?" }'
# ◂ returns the cited AnswerResult below — no parsing, no scrapingHybrid retrieve → rerank → typed cited highlights.
Lexical and dense semantic arms over the live-web index, fused and reranked. Returns passage highlights, each self-citing its source.
{ "highlights": [
{ "text": "…passage…",
"score": 0.91,
"source": { "url": "…" } }
],
"arms": { "lexical": true, "dense": true, "reranked": true }
}One grounded answer as typed data.
Consolidates highlights into a single answer: marker-per-claim citations, verified claims with evidence quotes, calibrated confidence, and a sufficiency verdict — the shape a model can act on without re-parsing.
{ "answer": "… [1] … [2]",
"citations": [{ "marker": 1, "url": "…" }],
"claims": [{ "text": "…", "verdict": "supported", "quotes": ["…"] }],
"confidence": 0.84, "sufficiency": "supported",
"grounding": "own-index"
}Deep research as an async run.
Returns a run id immediately. The engine iterates — answer, find the ungrounded claims, crawl the gap, re-answer — and checkpoints every step. Poll, stream SSE progress, or take the webhook.
{ "run_id": "run_5c1f…", "status": "queued" }
# GET /research/:id/events — SSE, resumes from Last-Event-ID
event: iteration → gap → crawl → completedA standing query with a webhook.
Watch a question instead of asking it once. Each sweep re-answers and diffs the grounded claim set deterministically; the webhook carries exactly what changed — added claims, removed claims, confidence delta.
{ "monitor_id": "mon_9b2e…",
"diff": { "addedClaims": ["the record is 105"],
"removedClaims": ["the record is 100"] },
"answer": "… [1]", "confidence": 0.81
}The MCP server itself — Streamable HTTP, stateless.
Search, answer, extract, research, and monitor as typed tools, each with an outputSchema. This is the front door most agents use.
{ "tools": [
"ipnops_search", "ipnops_answer", "ipnops_extract",
"ipnops_research", "ipnops_research_status", "ipnops_monitor"
] }
# each with an outputSchema — results arrive typed07 / 08
Run a model with no web access? Give it one MCP endpoint and it's grounded.
A local model on your laptop, an on-prem cluster, a sovereign AI behind an air gap — capable at reasoning, blind to the live web. They have no crawler, no index, no way to check a fact. Point one at Ipnops over MCP and grounded search, cited answers, and deep research arrive as typed tools. The model stays where it is; only the query leaves. Metered by API key — a developer subscription separate from the discovery product.
Any MCP-capable runtime
Ollama, LM Studio, a private inference server, an on-device agent — if it speaks MCP, it reaches the same six tools every hosted agent uses. No SDK to embed, no index to build, no crawler to run and maintain.
Grounding without a crawler
The hard part of grounding — a live-web index, hybrid retrieval, a verification gate, reach past bot walls — is exactly what a self-contained model can't build alone. Ipnops is that layer as a single endpoint, so a model with zero web access answers from real, cited evidence.
Your model, your key
Your weights and prompts never leave your environment — only the search query crosses the wire. Access is a per-key API subscription with its own rate limits and usage, scoped to your tenant and independent of the GEO/discovery plans.
08 / 08
Ground AI on data that never leaves your walls.
Ipnops is a managed service. For enterprises and sovereign data owners — teams whose corpus can't cross a border, a VPC, or a compliance line — the same engine ships as an enterprise deployment inside your own environment. Retrieval, verification, and synthesis run where the data lives. Not retrieval bolted onto a chatbot: a grounding layer between your data and every model and agent you run.
The stack is yours to run
The full engine — index, hybrid retrieval, reranking, verification gate — deployed in your own environment against your own data. Nothing leaves the perimeter to be grounded.
Bring your own reasoner
Point synthesis at your own model endpoint — a hosted model, a private inference cluster, whatever your compliance requires. Paid egress for open-web reach is opt-in, not baked in: a fully-local deployment makes zero outbound calls.
Beyond retrieval-and-hope
Simple RAG retrieves text and hopes the model uses it well. The Ipnops layer types it: claims, verdicts, evidence quotes, confidence, freshness — an auditable trail from every answer back to the exact passage that grounded it.
01 / 03
AI answers are the new front page. If the engines can't retrieve you, you're not ranked low — you're absent.
The buyer's first impression of you is now written by a model, from whatever it could retrieve — and it cites a handful of sources, not a page of them. Ipnops makes your real site citable: it observes which AI crawlers actually hit you, scores the on-page signals that decide retrieval, and applies the levers to the page you already ship. No shadow page, no cloaking.
Observe
A client tag reports your live on-page signals; a server SDK reads your request logs for real AI-crawler hits. Crawlers never run JavaScript, so the server side is the only place the truth shows up — who came, to which paths, and what they got.
Score
An on-page audit grades the four signals that decide retrieval: structured data (schema.org JSON-LD), server-rendered HTML, crawler access in robots.txt, and answer-first content with clear entities. Every page gets a per-engine score.
Enrich
Apply the levers to your real page — add the JSON-LD, ship server HTML, open the right bots. The copywriter rewrites your body copy in place to lead with the answer and keep every source fact, and the embeddable tag can inject Organization JSON-LD and freshness metadata for you. The next crawl sees a page built to be retrieved.
02 / 03
See who the AI answers reached — the metric SEO was never built to measure.
Rankings tell you where a blue link sits. They say nothing about whether a model cited you. Ipnops measures the new surface directly: every AI-crawler hit in your logs, scored per engine — and every time Ipnops itself cites your business in an answer to an agent, credited back to you, split by who asked.
AI-crawler analytics
Total crawler hits, blocked requests, and engines seen — trended over time and broken out per engine across all nine. You finally see which answer engines are actually reaching your pages, and which paths they read.
Surfaced-in-answer attribution
When Ipnops cites an owned host in an answer, the owner gets credit — no crawler UA ever touches the origin. Split by the citing agent's class: Private AI (MCP), assistant users, and search agents. It's citation share, made countable.
# credited when Ipnops cites you in an answer
{ "surfacedTotal": 1240,
"byClass": {
"mcp": 612, # private AI
"user": 431, # assistant users
"search": 197
} },
"crawlerHits": 8_930, "enginesSeen": 7
}03 / 03
One line for the tag. One import for the crawler truth.
Drop the client tag to report live on-page signals and inject the structured data engines look for. Add the server SDK to observe the AI-crawler hits the tag can never see. Then the dashboard shows who crawled you, per engine, and when an answer surfaced you.
<!-- reports signals + injects JSON-LD -->
<script async
src="https://api.ipnops.ai/geo/tag.js"
data-site="example.com"></script>// crawlers don't run JS — the server sees them
import { ipnops } from "@ipnops/geo";
app.use(ipnops({ site: "example.com" }));
// tags every AI-crawler request in your logs