Neonia Agentic Search
Show HN: The Global Llms.txt Index
Last verified:
What is Neonia Agentic Search?
Neonia Agentic Search (index.neonia.io) is the Global llms.txt Index, a search engine for the machine-readable web designed specifically for AI agents. It equips AI agents with deterministic API context by searching through llms.txt files across the web, eliminating hallucinations and preventing token bloat. The tool allows agents to find exact API documentation, rate limits, and structured documentation without guessing or browsing raw HTML.
Key features include searching the machine-readable web for llms.txt indices, providing deterministic API context to eliminate hallucinations, token-saving data pointers (neonia://), Governed Graph Memory for persistent agent memory powered by SurrealDB, Agentic Queues (Pub/Sub) for asynchronous task delegation, and infinite auto-discovery of tools through the neonia_sys_tool_discovery meta-tool. The platform offers zero-token reasoning through Wasm-based backend compute that processes data before it hits the LLM context.
Neonia is designed for AI agent developers, ML engineers building autonomous agent swarms, developers who want to skip local infrastructure setup (Pinecone, Redis, Docker), and teams building multi-agent systems that need shared memory and async coordination. It is particularly valuable for developers building agents that need to interact with APIs, parse documentation, or perform web scraping without context window overflow.
Neonia Agentic Search pricing
Pricing model: Freemium
System layer (Governed Graph Memory & Agentic Queues) is 100% FREE forever with no subscriptions. Billing uses HTTP 402 pay-per-invocation protocol with $0.001 precision. System Tools: $0.000/call. Standard Tools: $0.002/call (includes neonia_dev_package_analyzer, neonia_web_url_to_markdown, neonia_dev_version_checker). Advanced Tools: $0.005/call. AI Powered Tools: $0.015/call. Ultra Tools: $0.055/call. Top up a single developer balance and agents execute tools atomically. On-demand tool generation is fully refunded if technically unfeasible or restricted.
Neonia Agentic Search pros
- Free persistent Governed Graph Memory powered by SurrealDB
- Built-in Agentic Queues (Pub/Sub) for async task handoff
- Zero Docker config and no local Python environments needed
- Infinite auto-discovery of tools via neonia_sys_tool_discovery
- Token-saving neonia:// data pointers prevent context bloat
- Wasm sandbox provides zero-trust serverless compute
- System layer (memory & queues) is 100% free forever
- Pay-per-invocation billing with $0.001 precision via HTTP 402
- Native edge piping extracts insights before hitting LLM context
- Dual-Memory Shared Brain enables swarm agents to learn together
- On-demand tool generation with full refund if unfeasible
- Single MCP connection replaces multiple infrastructure components
- 111x cheaper and 2.5x faster data aggregation compared to raw routing
- Global causal graph lets all swarm agents inherit solutions instantly
- 20+ specialized dev tools available including regex extractor and package analyzer
Neonia Agentic Search cons
- Pay-per-call model requires balance top-up for tool usage
- New platform with limited community documentation compared to established tools
- Advanced tools cost up to $0.055 per call which can add up quickly
- Requires API key setup and MCP client configuration
- Primarily designed for agent workflows, less useful for single-shot tasks
- Depends on llms.txt adoption by documentation sites for optimal search
- Wasm compute pricing may be unpredictable for high-volume usage
- Platform still evolving with tools added regularly (v0.x versions)
Frequently asked questions about Neonia Agentic Search
What is Neonia and what problem does it solve?
Neonia is a managed MCP backend and the Cloud Backend for AI Agents. It solves the problem of developers having to build custom wrappers for memory and tool execution. Neonia provides zero-trust WebAssembly compute, persistent Graph Memory, and token-saving data pointers so agents don't overflow context windows or hallucinate. It replaces the need for local Pinecone, Redis, and Docker setups.
How does the Global llms.txt Index work?
The Global llms.txt Index (index.neonia.io) searches the machine-readable web by indexing llms.txt files from documentation sites. These files provide structured, Markdown-formatted documentation that LLMs can understand efficiently. Agents use this to find deterministic API context, rate limits, and exact documentation without browsing raw HTML or hallucinating URLs.
What is Governed Graph Memory?
Governed Graph Memory is free persistent memory for agents powered by SurrealDB. It uses a Dual-Memory system where agents separate cheap semantic state (neonia_sys_memory_note) from hard-learned causal rules (neonia_sys_memory_lesson). When one agent solves a problem, the global Swarm instantly inherits the exact Cause and Effect, eliminating RAG hallucinations and local JSON file messiness.
How does token arbitrage save money?
Token arbitrage works by delegating heavy payload handling to Neonia's backend Wasm infrastructure. For example, a 15MB API doc is minified on the backend and returns a lightweight neonia:// pointer instead of raw data. This saved ~3.5M LLM tokens and averted context collapse. Tools communicate natively on the backend, and a Wasm filter extracts 2KB of pure insight before hitting your LLM.
What is neonia_sys_tool_discovery?
neonia_sys_tool_discovery is a dynamic skill router that makes agents truly autonomous. If an agent needs to perform a task it doesn't know how to do (like parsing PDFs or checking stock prices), it searches the Neonia Gateway for the right tool instead of failing or hallucinating. It's free at $0.0/call and provides zero-setup access to the entire Neonia arsenal through a single entry point.
How do Agentic Queues work for swarm coordination?
Agentic Queues provide native IPC (Inter-Process Communication) for asynchronous task handoff. Agent A pushes a task to neonia_sys_queue_push and goes to sleep. Agent B picks up the task globally via neonia_sys_queue_pop. This replaces the need for heavy orchestrators like LangGraph or local Redis servers just to pass a single message between agents.
What is the HTTP 402 protocol?
HTTP 402 is the Agent-Native Billing protocol Neonia uses for pay-per-invocation logic. Developers top up a single balance, and agents execute tools atomically with $0.001 precision. There are no subscriptions—you only pay for the Wasm compute your agents actually consume. System layer tools are free, while Standard through Ultra tools have per-call pricing.
Can I request custom tools if they don't exist?
Yes, Neonia offers on-demand tool generation. You can request missing tools directly through the MCP interface. The automated factory synthesizes custom infrastructure requirements. If the API is technically unfeasible or restricted, you get a full refund. New tools like neonia_dev_package_analyzer and neonia_web_url_to_markdown are regularly added.
How do I connect my agent to Neonia?
Connect via a single standard MCP stream in under 1 minute. Add the Neonia API key to your headers, use streamable_http_client to connect to https://mcp.neonia.io/mcp, initialize the ClientSession, list tools, and create your agent with create_react_agent. No Docker config or local Python environments needed. Your agent gets Governed Graph Tools and zero-token reasoning immediately.
What is the Autonomous Flywheel?
The Autonomous Flywheel is how agents self-orchestrate without glue code: (1) Discover—agent uses Auto-Discovery to dynamically pull needed tools like a web scraper; (2) Native Compute—fetches large pages and pipes them through Wasm Filters so raw data never hits LLM context; (3) Delegate—drops extracted insights into async Task Queue for specialized agents; (4) Evolve—stores extraction logic in Shared Cloud Memory so the entire Swarm instantly knows how to handle similar sites.