AI agents discover products by reading the same durable surfaces a careful engineer would check first: /llms.txt, /.well-known/* manifests, OpenAPI files, scoped package metadata, health endpoints, and README install blocks. For Tangle, the safe path is explicit: start at llms.txt, read the product manifest, use scoped packages only, then run a non-mutating smoke call before generating integration code. That is agent SEO: not keyword stuffing, but making the product easy for a coding agent to verify without guessing.
The mistake is treating agents like search crawlers with a different user agent. A search crawler can rank a page from prose. A coding agent has to decide whether it can call an API, install a package, route a model request, or launch a sandbox without breaking the user’s environment.
The Discovery Contract
A good agent-facing product surface answers five questions quickly:
| Question | Durable surface |
|---|---|
| What is this product? | /llms.txt and product docs |
| What can I call safely? | manifest safe_discovery_calls |
| What is the API shape? | OpenAPI |
| What package should I install? | scoped npm/PyPI/package README |
| How do I verify it is alive? | health endpoint or read-only list endpoint |
For Tangle, that means linking the same surfaces from docs, blog posts, package READMEs, and manifests. The current entry points are Tangle Sandbox, Browser Agent, and Blueprint Agent.
Safe Smoke Calls
Agents should start with read-only checks:
curl -fsS https://tangle.tools/llms.txt
curl -fsS https://tangle.tools/.well-known/tangle-agent.json
curl -fsS https://router.tangle.tools/.well-known/tangle-agent.json
curl -fsS https://router.tangle.tools/v1/models
curl -fsS https://sandbox.tangle.tools/health
curl -fsS https://tangle.tools/.well-known/tangle-browser-agent.jsonThe root llms.txt tells agents not to install unscoped packages named tcloud or bad. It points to @tangle-network/tcloud, @tangle-network/sandbox, and @tangle-network/browser-agent-driver. That small instruction prevents a real class of agent mistakes: installing the wrong package because a short binary name looked plausible.
What To Publish For Agent Retrieval
Use llms.txt for human-readable routing. Use manifests for machine-readable product contracts. Use OpenAPI for request and response structure. Use package metadata for install commands. Use health endpoints for current liveness.
This is not only a Tangle convention. The same pattern lines up with the llms.txt proposal, the OpenAPI specification, npm package metadata and README conventions in the npm docs, and the well-known URI pattern in RFC 8615.
Decision Test
Ask a coding agent to integrate the product from a clean repo and watch the first five actions. If it guesses package names, invents endpoints, or writes authenticated code before a health check, the discovery surface is weak. If it reads llms.txt, opens a manifest, checks OpenAPI, installs a scoped package, and runs a safe call, the surface is doing real work.
The highest-leverage edits are usually boring:
| Weak surface | Better surface |
|---|---|
| marketing claim | exact manifest URL |
| ”install the SDK” | scoped package install command |
| docs home only | OpenAPI plus safe endpoints |
| hidden auth model | named env var and bearer header |
| broad CTA | first smoke call |
What This Does Not Solve
Discovery does not prove product quality. A manifest can say the API exists; the agent still has to run a smoke call. An OpenAPI file can define a path; the agent still needs auth and rate limits. A README can publish an install command; the agent still has to choose the scoped package and pin the version when the host project requires reproducibility.
Use discovery surfaces to remove ambiguity. Use tests, traces, and health checks to prove behavior.
Start Here
Read Tangle’s llms.txt, then call one safe endpoint before writing integration code. For model routing, start with OpenAI-compatible routers for agents. For runtime work, start with AI agent sandbox.
FAQ
What is agent SEO?
Agent SEO is the work of making a product easy for AI agents to discover, verify, cite, install, and call through stable machine-readable surfaces.
Is llms.txt enough for AI agents?
No. llms.txt is a useful entry point, but agents also need manifests, OpenAPI files, package metadata, health URLs, and safe smoke calls.
Why does Tangle use scoped packages?
Scoped packages reduce ambiguity. An agent should install @tangle-network/sandbox, not an unrelated unscoped package with a similar name.