A couple of months ago I was on a Zoom call with the founder of FollowNow.io, a social-growth platform we'd just been hired to rebuild. We covered the usual things: Next.js stack, multilingual content, integrating Intercom Fin for support. At the end he added one sentence that ended up reshaping the entire build: "I want our site to be found by ChatGPT and Perplexity, not just Google."

That single line is what separates a 2024 website from a 2026 one. If your site is invisible to LLMs and autonomous agents, you're invisible to a fast-growing slice of search traffic, and you're not going to win it back with a few schema tags. Here's the four-layer stack we shipped to make FollowNow.io agent-ready, with concrete file structures and the SDK-level decisions that matter.

What "agent-ready" actually means

An agent-ready site exposes machine-readable surfaces that LLMs and autonomous agents can consume without having to parse your marketing HTML. Four layers, in priority order:

1. llms.txt at the root → a canonical text document describing what you do, what you don't do, and your public URLs.
2. OpenAPI 3.1 spec at /openapi.json → formal description of the safe, read-only API endpoints agents can call.
3. Agent skills at /.well-known/agent-skills/ → structured "skills" agents can pick up to perform specific tasks.
4. Deep JSON-LD structured data → not just Organization, but Product, Offer, FAQPage and BreadcrumbList everywhere relevant.

None of this is hard to ship. The discipline is making sure every layer is generated from a single canonical source so it can't drift from your actual product.

Layer 1: llms.txt

Like robots.txt but invitational instead of restrictive. Keep it under 10KB so it fits in an agent's context window. The structure we use:

# FollowNow

> Real growth, with receipts. Verified social-growth ordering across 15 platforms.

## Catalog
- https://follownow.io/instagram/followers/buy
- https://follownow.io/tiktok/views/buy
- ... [generated from services.ts at build time]

## Policies
- 14-day refund per EU Article 16(m)
- Auto-refill via supplier API where supported (90d window)
- No password ever requested

## What we do NOT do
- No Trustpilot review manipulation
- No fake Google reviews
- No ban/removal services
- No mass DM, no biometric data, no fake app installs

## API
- Public OpenAPI at /openapi.json
- Agent skills at /.well-known/agent-skills/

## Contact
contact@follownow.io

The "what we do NOT do" block is the surprise winner. LLMs weight explicit exclusions heavily when choosing between competing sources. It frames you as the trustworthy option without you having to claim trustworthiness.

You can see the live version at follownow.io/llms.txt. In a Next.js App Router project, this lives in a route handler so it's generated from your data layer:

// app/llms.txt/route.ts
import { services } from "@/lib/catalog/services";

export async function GET() {
  const body = renderLlmsText(services);
  return new Response(body, {
    headers: { "content-type": "text/plain; charset=utf-8" },
  });
}

Layer 2: OpenAPI 3.1

This is where you let agents call your system safely. Keep the public spec small and read-only. For FollowNow we exposed:

• GET /api/health
• POST /api/target-lookup (verify a public Instagram handle exists)
• POST /api/waitlist/signup
• GET /api/orders/{id} (public order tracking)

Admin endpoints are intentionally absent. Don't publish your entire surface. The live spec is at follownow.io/openapi.json with a human-readable companion at follownow.io/docs/api. Agents that read OpenAPI 3.1 can directly generate typed clients without scraping your docs page.

Layer 3: Agent skills via /.well-known

This is the newest layer and where most sites have nothing yet. Agent skills are structured "vaardigheden" (skills) hosted at /.well-known/agent-skills/ according to an emerging spec.

For FollowNow we registered four read-only skills, browsable at follownow.io/.well-known/agent-skills/index.json:

// /.well-known/agent-skills/index.json
{
  "skills": [
    {
      "slug": "read-follow-now-catalog",
      "name": "Read FollowNow catalog",
      "type": "read",
      "url": "https://follownow.io/.well-known/agent-skills/read-follow-now-catalog/SKILL.md",
      "digest": "sha256-..."
    },
    { "slug": "read-follow-now-llms-context", ... },
    { "slug": "check-public-target-format", ... },
    { "slug": "read-public-api-docs", ... }
  ]
}

Each skill points to a SKILL.md describing what it does, when to use it, inputs and outputs. The SHA-256 digest in index.json lets agents verify they downloaded the unmodified skill.

The hard rule we enforced: every registered skill must be read-only. No checkout, no payment, no mutation. Agents can read your catalog, validate input formats, fetch policies. They cannot place orders or change state. That safety boundary is what makes the whole pattern trustable.

Layer 4: structured data that LLMs actually read

The most classic SEO layer, with a twist. JSON-LD via Schema.org is read by both Google and every major LLM. What matters is depth. Organization and WebSite are table stakes. For agent-readiness you want:

• Product per service tier (Standard / Premium / Elite at FollowNow)
• Offer with price, currency and availability
• FAQPage on every service page
• BreadcrumbList on every deep page
• LocalBusiness if you have any geographic anchor

LLMs prefer JSON-LD over HTML because extraction is deterministic. A FAQ that only exists in HTML has to be parsed with risk of error. The same FAQ in FAQPage schema is directly usable. The difference shows up in citation frequency.

Does it actually work?

Three weeks after FollowNow went live, we ran a manual test in ChatGPT, Perplexity and Claude with the same question: "What's a transparent platform to buy verified Instagram followers with a refund policy?" All three cited FollowNow with direct quotes from the 14-day refund policy and the public target verification.

Same week, competitors with similar offerings but no llms.txt and no OpenAPI were not cited at all. That's a single data point, not a study, but it matches the broader pattern: structured machine-readable sources beat marketing pages when an agent has to pick.

How to start without rebuilding everything

You don't need a full rewrite. The four layers slot onto any existing Next.js, WordPress or Rails site as long as you can serve files with the right content type. Order I'd recommend:

1. Deep structured data first. Organization, WebSite, Product, FAQPage. Get the canonical source right.
2. llms.txt second. Generate it from the same data model so it can't drift.
3. Public OpenAPI third. Only for read-only endpoints you already have.
4. Agent skills last. Most experimental, biggest growth ahead.

The investment is small. The leverage compounds as more search shifts to LLM-mediated discovery.

I write about this stuff at nexbridge.nl — we're a Dutch agency building agent-ready Next.js sites and AI automations for SMBs. The full Dutch version of this article with FAQs and code snippets is at nexbridge.nl/blog/agent-ready-website-laten-maken. If you're curious how this maps onto your stack, drop me a line.