---
title: "Build with agents"
description: "Give a coding agent the exact SeatLayer context, constraints, and verification criteria it needs to implement an integration."
---

SeatLayer publishes the same documentation in two forms: a designed site for people and clean Markdown for coding agents. You should not have to rewrite product knowledge into a prompt before an agent can help.

For chart-aware product help, start with [Copilot overview](/copilot/overview).
For an external agent, review the [capability matrix](/agents/capabilities), then
use the client-specific setup for [Codex](/agents/connect-codex),
[Claude](/agents/connect-claude), or [ChatGPT](/agents/connect-chatgpt).
For a coding agent working inside your own repository, follow
[integrate SeatLayer with an agent](/agents/integrate-seatlayer/).

<Aside type="tip" title="Best starting point for an agent">
  If the client supports remote MCP, connect the public, anonymous
  `https://docs.seatlayer.io/mcp` endpoint. Otherwise give the agent
  `/llms.txt`, the page for the task, and access to your repository. Ask it to
  inspect your existing checkout architecture before it writes code.
</Aside>

Call `product_overview` first when the agent needs the canonical short answer:
what SeatLayer is, who it fits, embedded versus hosted ownership, the checkout
trust boundary, current public SDK, pricing basis, agent surfaces, non-fit
cases, and source URLs. Use the specialist tools only after that orientation.

## Install the SeatLayer AI Toolkit

The open-source [SeatLayer AI Toolkit](https://github.com/seatlayer/seatlayer-ai-toolkit)
packages the repository-first workflow as a portable skill. It adds focused
live-doc routing, a read-only integration doctor, verification checklists, and
optional Designer MCP configuration. The public Markdown documentation remains
the source of truth.

<Tabs>
  <TabItem label="Codex">
    ```bash
    git clone https://github.com/seatlayer/seatlayer-ai-toolkit.git
    cd seatlayer-ai-toolkit
    node scripts/install.mjs --target codex
    ```

    Then ask Codex: `Use $integrate-seatlayer to add reserved seating to this repository.`
  </TabItem>
  <TabItem label="Claude Code">
    ```bash
    git clone https://github.com/seatlayer/seatlayer-ai-toolkit.git
    claude --plugin-dir /absolute/path/to/seatlayer-ai-toolkit
    ```

    Start with `/seatlayer:setup`, then use `/seatlayer:integrate`.
  </TabItem>
  <TabItem label="GitHub Copilot">
    ```bash
    git clone https://github.com/seatlayer/seatlayer-ai-toolkit.git
    cd seatlayer-ai-toolkit
    node scripts/install.mjs --target github --project /path/to/project
    ```
  </TabItem>
  <TabItem label="Any agent">
    Give the agent `https://docs.seatlayer.io/llms.txt` and the toolkit's
    `skills/integrate-seatlayer/SKILL.md`.
  </TabItem>
</Tabs>

Run the deterministic doctor without installing anything:

```bash
node scripts/doctor.mjs /path/to/project
```

## Agent-readable surfaces

| Resource | Use it for |
|---|---|
| `/llms.txt` | Compact index with the right page for each task |
| `/llms-full.txt` | Complete documentation for a large context window |
| `/sdk-catalog.json` | Exact SDK packages, published versions, primary surfaces, and inventory-model support |
| `/<page>/index.md` | Clean Markdown for one rendered page |
| `/<section>/llms.txt` | All pages in one section |
| `https://docs.seatlayer.io/mcp` | Public, anonymous, read-only product knowledge and documentation search |
| `/.well-known/mcp.json` | Discovery list with the public knowledge MCP first and the authenticated Designer MCP second |
| `/openapi.json` | OpenAPI 3.1 discovery description for the public server API |
| `/.well-known/api-catalog` | RFC 9727 links to the API, OpenAPI description, docs, health, and MCP |
| `/.well-known/mcp/server-card.json` | Singular Designer MCP card, capabilities, and OAuth discovery |
| `/.well-known/agent-card.json` | Public read-only A2A documentation router |
| `/.well-known/agent-skills/index.json` | Integrity-pinned SeatLayer integration skill |
| `/auth.md` | Agent-readable OAuth registration and chart-scoped consent boundary |
| [SeatLayer SDK](https://github.com/seatlayer/seatlayer-sdk) | Inspect supported JavaScript and React package source |
| [SeatLayer for Flutter](https://pub.dev/packages/seatlayer) | Install the Flutter package; inspect source in [seatlayer/seatlayer-flutter](https://github.com/seatlayer/seatlayer-flutter) |
| [SeatLayer iOS SDK](https://github.com/seatlayer/seatlayer-ios) | Integrate the SwiftUI/UIKit picker or raw Swift map API |
| [SeatLayer React Native SDK](https://github.com/seatlayer/seatlayer-react-native) | Integrate the typed Expo, iOS, and Android picker or raw-map API |
| [SeatLayer Android SDK](https://github.com/seatlayer/seatlayer-android) | Integrate the Compose/View picker, headless state, or raw Kotlin map API |
| [SeatLayer AI Toolkit](https://github.com/seatlayer/seatlayer-ai-toolkit) | Install the portable agent workflow and diagnostics |
| [SeatLayer GitHub](https://github.com/seatlayer) | Discover all public SeatLayer repositories |

The Markdown pages are generated from the same source as the human docs. They do not drift into a separate, abbreviated “AI version.”

Browsers that implement WebMCP also receive one read-only
`find_seatlayer_resource` tool. It returns authoritative documentation URLs; it
cannot authenticate, edit charts, change inventory, book seats, or publish.

## What an agent must understand first

Before implementation, the agent should be able to state these invariants:

1. A **chart** is reusable venue geometry; an **event** is a published chart with independent live inventory.
2. The **browser holds** seats. **Your server books** them after it validates the hold and runs payment or order logic.
3. A secret key is server-only. It must never appear in a browser bundle, mobile app, log, screenshot, or generated example.
4. Prices and item details used for charging come from the server-side hold inspection, never from browser input.
5. `bookingRef` is a stable order reference and makes booking retries idempotent.
6. A `409` is a normal inventory conflict path and must have an intentional buyer experience.

## A prompt that produces a better implementation

```text title="seatlayer-agent-prompt.txt"
Implement SeatLayer reserved seating in this repository.

Read first:
- https://docs.seatlayer.io/llms.txt
- https://docs.seatlayer.io/start/quickstart/index.md
- https://docs.seatlayer.io/examples/complete-checkout/index.md
- https://docs.seatlayer.io/integrations/best-practices/index.md

Before changing code:
1. Inspect the existing frontend, backend, checkout, payment, environment-variable,
   error-handling, and test patterns.
2. Explain where the SeatLayer browser picker and server booking call belong.
3. Identify any decision you cannot safely infer.

Implementation constraints:
- Browser holds; server books.
- Never expose SEATLAYER_SECRET_KEY to client code.
- Inspect the hold server-side and calculate the charge from its items.
- Use the existing order id as bookingRef and safely retry with the same value.
- Treat HTTP 409 as a recoverable inventory conflict.
- Preserve the repository's framework conventions and styling.
- Add tests for success, expired hold, booking conflict, duplicate retry, and
  missing server credentials.
- Do not invent SDK methods or response fields. Use the documented HTTP contract.

When finished:
- Run the repository's typecheck, tests, lint, and build.
- Report changed files, assumptions, and any production configuration still needed.
```

Replace the URLs with local Markdown routes if the agent can browse the running docs site.

## Recommended agent workflow

<Steps>
  <Step title="Orient">
    Read the overview and inspect the host repository. Locate the checkout boundary, payment authority, order identifier, environment handling, and current tests.
  </Step>
  <Step title="Plan against contracts">
    Name the browser-to-server payload, the server-to-SeatLayer requests, every credential location, and the failure behavior before editing.
  </Step>
  <Step title="Implement the smallest complete loop">
    Render → select → hold → inspect → pay → book. Avoid unrelated refactors and avoid hiding essential behavior inside a demo-only abstraction.
  </Step>
  <Step title="Test failure paths">
    Prove expired holds, `409` conflicts, payment failures, duplicate booking retries, and missing credentials—not only the happy path.
  </Step>
  <Step title="Hand off">
    Return changed files, verification output, assumptions, environment variables, webhook work, and the exact manual journey a human should test.
  </Step>
</Steps>

## Designer agents

The remote Designer MCP lets an authorized agent inspect a private venue reference, create deterministic geometry, validate the result, and submit evidence for review.

<Aside type="caution" title="Publication boundary">
  An agent may propose and edit chart geometry, but it does not publish automatically. Authoritative seat labels, capacity, accessibility data, pricing, and a human review are still required.
</Aside>

Connect from **Dashboard → Agent connections**. The endpoint is environment-specific and the product guides the OAuth 2.1 + PKCE authorization for a specific chart.

## Definition of done

An agent-assisted integration is not complete until:

- the secret key is read only on the server;
- the backend ignores buyer-supplied pricing;
- the same `bookingRef` can be safely retried;
- conflict and expiry paths return the buyer to a useful state;
- responsive, keyboard, and mobile behavior have been checked;
- test-mode inventory completed an end-to-end booking;
- generated code follows the host application's conventions; and
- the human owner can explain the resulting data flow.

Continue with the [complete checkout example](/examples/complete-checkout) or the [platform integration guide](/integrations/platforms).