The search engine
for AI.
Agents already run most of the web. They don't need blue links — they need answers they can trust. Ipnops is search built natively for AI: one MCP call, typed cited facts, over its own crawled index.
# your agent calls the tool — a cited answer comes back
▸ 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
Agents speak MCP. So does Ipnops.
Ipnops ships an MCP server as its front door. Add one connector and search + grounded answers appear as tools inside whatever runtime you already run — Claude, your own agent, anything MCP-native. No SDK, no glue.
# one line — Ipnops becomes an agent tool
{
"ipnops": {
"transport": "http",
"url": "https://api.ipnops.xyz/mcp"
}
}Typed cited highlights over the own-index. Hybrid retrieve → rerank → passages that carry their own source.
One grounded answer with claim-level citations and a faithfulness report. The shape a model can quote verbatim.
Every tool ships an outputSchema, so the result is typed structure — not a wall of text your model has to re-parse.
Built to be read by a model, not a person.
Human search engines return ten links and hope. AI-native search does the reading at retrieval time and hands back structure a model can act on — with the receipts to prove it.
Claim-level citations
Not a source list — every claim in the answer carries the exact passage it came from, so the agent can verify without re-searching.
Typed, not scraped
Passage chunks with provenance, returned as JSON an agent consumes directly. Pass an output_schema and get exactly your shape back.
Grounded or it says so
A deterministic faithfulness check runs on every synthesized answer. If nothing grounded a claim, the response tells you — no confident fabrication.
The same index, over plain HTTP.
Not every runtime is MCP-native yet. The identical behaviour is three POST endpoints away — same index, same typed cited output. A raw request is one line; the response is already model-shaped.
# same call an agent makes over MCP — here as raw HTTP
curl -sS https://api.ipnops.xyz/answer \
-H "content-type: application/json" \
-d '{ "query": "who maintains the sqlite file format?" }'
# ◂ returns the cited AnswerResult below — no parsing, no scrapingHybrid retrieve → RRF → rerank → typed cited highlights.
BM25 lexical + dense pgvector arms, fused with weighted RRF and reranked by a cross-encoder. 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 with claim-level citations.
Consolidates highlights into a single answer with its own tiered reasoner, marker-per-claim citations enforced, and a faithfulness report attached.
{ "answer": "… [1] … [2]",
"citations": [{ "marker": 1, "url": "…", "text": "…" }],
"grounding": "own-index",
"faithfulness": { "grounded": true }
}The MCP server itself — Streamable HTTP, stateless.
The same search + answer path any MCP client reaches, exposed as tools with typed outputSchema. This is the front door most agents use.
# tools/list
{ "tools": [
{ "name": "search", "outputSchema": {…} },
{ "name": "answer", "outputSchema": {…} }
]
}Its own index first. The open web when it must.
Ipnops crawls and indexes the open web itself — a real engine, not a meta-search wrapper. When the own-index misses, a reach ladder falls through to live fetch-and-extract and place data, never dead-ending.
Own crawled index
An intelligent, agent-driven crawler stores structured passage chunks with claim provenance in a hybrid pg_search + pgvector index.
Reach ladder
Own-index → live web fetch-and-extract → OSM/Nominatim place data. Each tier is grounding-checked, so a miss degrades cleanly instead of guessing.
Self-host
The stack is yours to run. Bring your own reasoner behind an OpenAI-compatible endpoint; the paid egress dependency is opt-in, not baked in.
It reaches what search can't.
The data an agent needs is increasingly behind a login, on a canvas, or inside an app with no API. When there is nothing to crawl and no endpoint to call, Ipnops goes in and operates the interface directly — an autonomous browse loop for the semantic web, computer-use for everything else.
Autonomous browse
A plan → act → reflect loop drives a live browser and self-corrects on failure. The frontier is proof: the best agents now clear 92%+ on live-web tasks.
Computer-use
When the DOM lies — canvas UIs, logged-in surfaces, apps with no API — a computer-use agent works the pixels. On desktop control, these agents now pass the human baseline (OSWorld: 85% vs 72%).
Ground once, replay forever
Agentic browsing usually calls a model on every step of every run. Ipnops grounds once and replays deterministically — O(steps×runs) inference collapses to O(1), for 99% fewer tokens on repeat tasks.