---
title: Built for agents
description: What effract ships for coding agents — a canonical AGENTS.md, an installable skill, llms.txt, a markdown docs mirror, Context7 rules, version-matched bundled docs, and a compile-checked feedback loop that keeps an agent honest.
group: Start
order: 6
---

In 2026, agent-readiness is a differentiator in its own right. A library your coding agent understands is
a library it can use correctly on the first try — no scraping, no stale training data, no invented API.
effract ships a lot for agents, on purpose. Here is what is in the box.

## `AGENTS.md` — the canonical agent guide

[`AGENTS.md`](https://github.com/get-tmonier/effract/blob/main/AGENTS.md) at the repo root is the canonical
guide for agents: the REC rules (a REC is not a JSX element — you place a child with `{yield* Child}`), the
single `mount`, the atom/`query` toolkit, the Effect conventions, and the common compile errors with their
fixes. It is written for an agent whose training data predates effract, and it tells that agent to prefer
the bundled docs over its priors.

`@tmonier/create-effract` drops an `AGENTS.md` **fragment** into the consumer repo, between
`<!-- BEGIN:effract -->` and `<!-- END:effract -->` markers, pointing the agent working in your codebase
at the bundled docs. The markers make it idempotent — re-running the scaffold updates the fragment in
place without touching the rest of your `AGENTS.md`.

## An installable skill

`skills/effract/SKILL.md` follows the [agentskills.io](https://agentskills.io) spec. Install it into an
agent with:

```bash
npx skills add get-tmonier/effract
```

The skill teaches an agent to scaffold a service + a REC, decide **client-island-vs-server**, migrate a
`useState`/`useEffect` component to a REC, and fix effract's compile errors — each as a concrete,
copy-pasteable recipe.

## `/llms.txt` and `/llms-full.txt`

This site serves [`/llms.txt`](/llms.txt) — an agent-facing index of the docs — and the full-corpus
[`/llms-full.txt`](/llms-full.txt), every docs page concatenated, so an agent can pull the entire
documentation set in one request instead of crawling. Both are generated from these pages at build time,
so they never drift.

## A markdown mirror of every page

Every docs page has a plain-`.md` twin. Append `.md` to any docs URL — for example
[`/docs/patterns.md`](/docs/patterns.md) — and an agent gets the raw markdown source, no HTML scraping
required. The dense [**canonical patterns**](/docs/patterns/) page is built for exactly this: one rule per
heading, each with a short compiling example, so an agent can lift a correct pattern verbatim.

## Context7

[`context7.json`](https://github.com/get-tmonier/effract/blob/main/context7.json) at the repo root ships a
set of canonical-usage `rules` that Context7 shows to an agent alongside code snippets — the same guardrails
as `AGENTS.md`, delivered through the agent's Context7 lookup.

## Version-matched bundled docs

The `docs/` folder ships **inside** the `@tmonier/effract` npm tarball. An agent working in your project
reads `node_modules/@tmonier/effract/docs/` and gets documentation that always matches the installed
version — never the model's stale training data, never a mismatched release on the web. The version the
agent reads about is the version it is coding against.

### Design records

The bundle includes `docs/adr/` — every architectural decision, written down, for agents and humans
alike:

- [ADR 0001 — Fiber reconciliation](https://github.com/get-tmonier/effract/blob/main/docs/adr/0001-fiber-reconciliation.md) — how an Effect generator becomes a real React component.
- [ADR 0002 — Async & runtime lifecycle hardening](https://github.com/get-tmonier/effract/blob/main/docs/adr/0002-async-lifecycle-hardening.md) — async work, cache keys, and runtimes made deterministic across React's render lifecycle.
- [ADR 0003 — The data story](https://github.com/get-tmonier/effract/blob/main/docs/adr/0003-data-story.md) — the live query cache, mutations, and streams.
- [ADR 0004 — Universal state](https://github.com/get-tmonier/effract/blob/main/docs/adr/0004-universal-state.md) — serialization, hydration payloads, per-request scope, and runtime injection.
- [ADR 0005 — DX moat](https://github.com/get-tmonier/effract/blob/main/docs/adr/0005-dx-moat.md) — devtools, testing, and error DX.
- [ADR 0006 — Transparent hydration](https://github.com/get-tmonier/effract/blob/main/docs/adr/0006-transparent-hydration.md) — `renderToStream` embeds the settled state, `mount` seeds it; no hydration API.
- [ADR 0007 — The render channel](https://github.com/get-tmonier/effract/blob/main/docs/adr/0007-render-channel.md) — render behaviour as the fourth compile-checked channel (`V`, labels, the ledger).
- [ADR 0008 — The query cache is a service](https://github.com/get-tmonier/effract/blob/main/docs/adr/0008-query-cache-service.md) — `QueryCache` as a built-in service; mutations declared in services.

## `@tmonier/create-effract`

```bash
npm create @tmonier/effract
```

An **idempotent, non-interactive** scaffold. Safe to re-run: it drops the `AGENTS.md` fragment, wires up
the example, and gets an agent (or a human) from zero to a running effract app without prompts.

## The compile-checked obligations _are_ the agent feedback loop

Everything above helps an agent write effract. This is what stops it from writing effract **wrong**.

An agent cannot ship an unhandled error — `.catch` is exhaustive over the tagged error channel, so a
missing tag is a compile error. An agent cannot ship an unhandled loading state — a `query`/`suspend`
puts a loading obligation in the REC's type that only `.suspense(fallback)` or `mount(layer, Root,
{ loading })` discharges. And an agent cannot ship a render storm — a stream atom puts a
[volatility obligation](/docs/render-control/) in the type that only `defer(atom)` or `.hot()`
discharges. `mount` will not compile until all three are handled.

```tsx
import { rec, mount, query } from '@tmonier/effract';

const Profile = rec(function* () {
  const user = yield* query(fetchUser(id), id); // suspends; E = NotFound
  return <Card user={user} />;
})
  .catch({ NotFound: () => <Empty /> }) // forget a tag → won't compile
  .suspense(<Spinner />);               // omit this → mount won't compile
```

The compile-checked obligation is the feedback loop. An agent iterates against the type-checker, not
against a bug report from production three days later. The type system is the guardrail that keeps an agent
honest — the same way it keeps a human honest. And render behaviour is part of the loop:
[`RendersOn<typeof C>`](/docs/render-control/) locks a component's subscription set in a type test — a
widened set fails CI by name — and in dev `readRenderLedger()` tells an agent exactly why anything
rendered.