# Fóir: the backend your agents build on, paid in $FOIR

Fóir gives an application its whole backend from one config file: a GraphQL API, a console for your team, sign-in and roles, and the isolation between your customers' data. A coding agent can write the config and run the project through an MCP server, so the app it builds is ready for real customers.

Every call the runtime answers is metered, priced in **$FOIR** and settled on Solana. An agent holding a wallet and no account can pay for an API request and carry on. 70% of the $FOIR spent on the platform is bought back and burned.

This is the plain version of foir.run, for agents and for anyone who would rather read than watch.

## $FOIR

- Utility token of the runtime, on Solana. Contract address: **coming soon**, announced at https://x.com/foir.
- What it pays for: every resolution, operation, AI credit, media transformation and API request the runtime serves.
- How a machine pays: x402 over HTTP. A request without credit returns 402 with a price; the client signs a $FOIR transfer on Solana; the same request is served. No account, no key, no invoice.
- What holders get: staked $FOIR raises the same ceilings a plan does. 25,000 $FOIR staked carries Starter limits.
- What happens to it: 70% of platform revenue is bought back and burned on-chain; the rest funds the runtime.
- Status: launching on Solana. The contract address is published at https://x.com/foir first, then on this page.

## Start with an agent

Connect the MCP server and read the contract from there. It lists the tools your role allows and searches the documentation.

```
foir mcp
```

- MCP setup: https://foir.run/features/mcp
- Documentation index: https://foir.run/index.md
- Everything the runtime does: https://foir.run/features

## Why teams choose it

- One config file gives you the backend you would otherwise assemble from separate services: database rules, sign-in, a content editor, media delivery, notifications and billing.
- Customer isolation is enforced in the database. Access rules compile to row-level security, so a check someone forgot cannot leak a row.
- The API is generated from your models, so there is no hand-written endpoint to get wrong.
- Content resolves on every request. A new language or audience is a field you set, and nothing is rebuilt.
- It is fully managed. There is nothing to host, patch or scale.
- You stay in control. Your code runs on your own hosting, payments settle to your own wallet, and every record exports to a Postgres database you own.
- Agents work safely in it. Writes land as drafts, tokens carry only the permissions you approved, and a person signs off what goes live. An agent without a token pays per call in $FOIR instead.
- Its authorisation engine, Demesne, is open source: https://foir.run/demesne

## Who it is for

- A product sold to many customers. Each customer is an organisation with its own data, members and sign-in, on shared models.
- An app built with a coding agent that is ready for real sign-in, roles and data isolation.
- An agency running many client projects on one platform, each metered separately.
- A content-led site or app that wants drafts, scheduled campaigns and personalisation.

## What you get

| Capability | What it does |
| --- | --- |
| Generated API | A GraphQL API built from your models. |
| Console | An editor for every model, with versions, live collaborative editing and preview as an audience. |
| Ask Fóir | An assistant in the console that answers questions about your data and makes changes as drafts, inside your role. |
| Sign-in | One hosted login: passkeys, two-step verification, and Google, Apple, Shopify or any OIDC provider. |
| Users and roles | One set of users in pools, with memberships and roles built from one list of permissions. |
| Organisations | Turn an app into a SaaS: each of your customers gets a boundary enforced as row-level security. |
| Keys | Publishable, server and admin keys. A key's schema contains only what it was granted. |
| Records | Records can be private to the user who owns them. Updates take an idempotency key, so a retry is safe. |
| Publishing | Writes land as drafts. Publishing needs no rebuild. Rollouts ship a campaign together and can be rolled back. |
| Personalisation | Variants chosen on the server from location, segments and your own dimensions. A variant can replace a record or one field. |
| Operations | Your own code, called through the API with a signed, scoped token. Every run is recorded. |
| Secrets | A vault. Functions and agents hold a reference and never the key. |
| Hooks | Record and operation events run operations, with deliveries you can send again. |
| Payments | A quota per user, organisation or agent on any operation. Over it, the caller pays per request over x402 in $FOIR, or by card through Stripe. |
| Metering | Every call is counted, priced in $FOIR and settled on Solana as it is served. |
| Notifications and email | Push and inbox notifications with per-person preferences. Email templates filled from records at send time. |
| Media, search, location | Images served as WebP and AVIF at each screen's size. Search by meaning. Distance queries. |
| Work | Notes left on a live page become tasks. Agents draft and people approve. |
| Agents | A long-running agent keeps content current over MCP, on a key that bounds what it can change and a balance that bounds what it can spend. |
| Apps | Your app's own admin pages inside the console, and integrations that keep another system's records in step. |
| Export | Every record exports to a Postgres database you own. |

Each of these has a page on this site: https://foir.run/features

## How a project starts

1. Load $FOIR, or let your agent pay per call over x402. No signup step, no card.
2. `foir workspaces create --name acme --select`
3. Write `foir.config.ts` with your models, then `foir push`.
4. Run `foir mcp` so an agent can work in the project as the signed-in person.

## Pricing, in $FOIR

Every plan is the whole platform. What changes is how much of it you use.

- Entry — 3,000 $FOIR a month (25,000 a year). One project, 5 people, 25,000 records, 10,000 signed-in end users.
- Starter — 90,000 $FOIR a month. Three projects, 10 people, 500,000 records, 25,000 end users.
- Pro — 310,000 $FOIR a month. Ten projects, 20 people, 2,000,000 records, 100,000 end users.
- Enterprise — custom ceilings and terms, paid in $FOIR or stablecoins on the same rails.

Overage is per call and per unit, never per seat. Staked $FOIR raises a workspace's ceilings without changing plan: https://foir.run/pricing

## Good to know

- Location, sign-in state and segments are worked out on the server, so personalisation cannot be spoofed by editing a request.
- A response that contains a resolved variant is marked private, so a shared cache never caches one visitor's version for another.
- How Fóir compares with Supabase, Firebase, Sanity, Payload and others: https://foir.run/compare
- Everything in this file resolves to https://foir.run. The token is announced at https://x.com/foir.