Reliable autonomy depends on plumbing the demo can ignore
The Boring Infrastructure AI Agents Need: Identity, Skills, and Retrieval
An agent needs to find the right service, prove that it reached the intended endpoint, know how to use the interface, and retrieve enough evidence for the task. Hardcoded integrations and fresh exploration on every run do not compound.

Agents cannot depend on hardcoded service URLs, relearn the same website each morning, or accept one opaque search bundle. Reliable systems need verifiable discovery, reusable skills, and retrieval primitives they can inspect.
Service discovery needs a trustable directory
Agent systems often keep private registries of URLs, tool descriptions, and credentials. Those records drift when a service moves or a new version appears. An agent may call the wrong endpoint while the team believes it reached an approved service.
DNS-AID proposes DNS as a vendor-neutral way to publish, discover, and verify agents and MCP servers. The specific standard may change. The requirement will remain: discovery needs ownership, identity, versioning, and a verification path.
Reusable skills prevent expensive relearning
A browser agent can spend tokens rediscovering selectors, navigation, and request patterns each time it visits a site. That exploration may work once and fail after a minor interface change. A reusable skill records the proven path and the assumptions behind it.
Skills need owners and tests. A saved selector can become stale too. Record the site version or last validation date, keep the skill narrow, and detect failure before the agent clicks through a different flow.
- 01Publish a verifiable service identity and supported version.
- 02Install narrow skills instead of repeating open-ended exploration.
- 03Test skills against the current interface.
- 04Keep credentials and permissions outside the skill definition.
Retrieval should expose useful primitives
A search API that returns one polished bundle limits the agent’s ability to rank, filter, fan out, and preserve intermediate evidence. Perplexity’s Search as Code work explores a lower-level approach where an agent uses code and a sandbox to build the retrieval path it needs.
That flexibility adds cost and risk. Set limits on queries, domains, runtime, and parallel work. Keep citations and intermediate results so a reviewer can understand how the agent reached the answer.
Deterministic code should carry stable responsibilities
Use code for validation, permission checks, deduplication, budgets, and output schemas. Let the model choose among uncertain search paths or interpret messy pages. This division keeps the agent from spending reasoning tokens on rules the team can state.
Narrow primitives also make evaluation easier. The team can test discovery, skill execution, retrieval quality, and synthesis as separate stages instead of grading one final answer.
Cache capability without hiding freshness
Reusable skills and retrieval plans reduce repeated discovery cost. They can also preserve stale assumptions. Attach last-checked dates and invalidation rules. A site change, service version, or repeated execution failure should send the item back to discovery.
The agent needs to know when to trust memory and when to look again. That decision belongs in the system design, not in an improvised prompt.
Measure the infrastructure by failed handoffs
Track discovery failures, skill invalidations, retrieval cost, unsupported claims, and the time a person spends recovering a run. A lower token bill means little if the saved skill sends the agent into the wrong account.
Boring infrastructure earns its place by making work repeatable and inspectable. The team should see fewer mystery failures as the catalog, skills, and retrieval controls mature.
What to keep
- 01Verify service identity and version during discovery.
- 02Store narrow, tested skills for repeated interfaces.
- 03Give agents retrieval primitives with budgets and citations.
- 04Invalidate cached capability when the service or interface changes.
Frequently asked
What infrastructure does an AI agent need?
A reliable agent needs verifiable service discovery, scoped identity, permissions, reusable and tested skills, retrieval tools, deterministic validation, budgets, observability, and clear invalidation rules.
Why should browser agents use reusable skills?
Reusable skills preserve tested navigation and request patterns, which reduces repeated exploration and token cost. Teams must still validate the skills and invalidate them after site changes.
Sources and further reading
- 01DNS-AID project announcement — Linux Foundation
- 02Browse.sh reusable browser skills — Browserbase
- 03Rethinking Search as Code Generation — Perplexity Research