The CMS built for AI coding agents.

Supatent lets agents work the way they already do: edit files on disk. The CLI validates and syncs draft content to the platform, and your team controls which version gets published.

See the workflow
CLI sync
Draft/publish control
TypeScript client
.supatent/content/home.en-US.json
draftlocal file
{  "headline": "The CMS built for AI coding agents",  "cta": "Request access",  "status": "draft"}
Agent notes
Editable in repo
Files stay on disk where agents already work.
Draft-first sync
Validation and push target draft state, not production.
Human publish step
Release remains an explicit action in the product.
Agent command loop
pull->validate->push
The repo remains the working surface; Supatent becomes the reviewed delivery layer.
Release model
Mutable draftReviewed publishRollback when needed
File-native workflow

Agents edit files. Supatent syncs drafts. You publish.

Keep CMS work where AI coding agents already operate: in your repository. The CLI handles sync and validation; Supatent keeps the draft and published states separate.

Local mirror01

Pull content to files

Schemas and content live in .supatent/schema/ and .supatent/content/, so agents can work in the same file system as the rest of your app.

$npx @supatent/cli pull
Agent loop02

Let the agent edit drafts

The CLI validates local changes and writes machine-readable status for coding agents to inspect and fix.

$npx @supatent/cli validate --json
Remote draft03

Push draft to Supatent

The CLI syncs local changes to the remote draft state in Supatent. Agents keep working against draft content.

$npx @supatent/cli push
Human gate04

Publish the reviewed draft

A person reviews the draft in Supatent and promotes it to the immutable published version when it is ready to go live.

Publish in Supatent
Client package

Query Supatent content from your app.

Use @supatent/client for published content and assets. The same package includes browser, React, Astro, webhook, markdown asset, and preview-mode helpers.

Published reads first
Read production content by default, then add API keys when you want preview or draft mode during development.
Framework-aware exports
Use the same package from server code, browser clients, React, Astro, and webhook handlers.
Content-aware assets
Assets, markdown references, and locale context stay close to the content models they belong to.
app/content.ts
@supatent/client
import { createClient } from "@supatent/client";

const cms = createClient({
  baseUrl: "https://app.supatent.ai",
  projectSlug: "marketing-site",
  locale: "en-US",
});

const page = await cms.schema("landing-page").bySlug("home");
const posts = await cms.schema("blog-post").paginate({ limit: 10 });
const hero = await cms.asset("hero-image");
Note

Shared contract

Schema names, locales, assets, and preview behavior all stay in the same client surface instead of being split across bespoke fetch logic.

Includes
browserreactastrowebhooksmarkdownassets
Optimized serving

Published content is ready to serve.

Supatent handles the serving layer for you. Published content is already cached, invalidated on publish, and exposed through APIs built for production delivery. Images are returned with optimized URLs and responsive variants, so there is no extra optimization pipeline to build before your app consumes the content.

Delivery handled

Publish once. Delivery stays fast.

Once a version is published, Supatent makes it available with caching and asset optimization already applied, so your app or website gets production-ready content without an extra delivery pipeline.

Cached globally
Published content and asset metadata are served with CDN and stale-while-revalidate cache headers already applied.
Fresh after publish
When a version is published or rolled back, Supatent syncs the published tables and revalidates cached project data.
Images optimized
The client wraps image assets with optimized URLs, responsive srcset generation, presets, and quality controls.
Tools

Tools for AI-assisted content work.

The CLI handles local sync. The client handles application reads. Skills and docs tooling give coding agents the project-specific instructions and content surfaces they need to work cleanly.

Agent runtime
@supatent/cli
npm

Sync schemas and content between local files and Supatent. Use init, pull, validate, status, push, dev, and merge in agent workflows.

$npx @supatent/cli dev
Application reads
@supatent/client
npm

Query published content from TypeScript apps, with subpath exports for browser, React, Astro, and webhook verification.

$npm install @supatent/client
Agent guidance
@supatent/skills
npm

Install Codex and Claude Code skills that teach agents how to manage Supatent schemas, blog posts, landing pages, and SEO-oriented content.

$npx @supatent/skills
npm

Render documentation from Supatent content in Next.js. The package supports static-first docs, search assets, and static AI outputs.

$npm install @supatent/supatent-docs
SEO and locales

Built for content that has to be found.

Supatent treats structured metadata and translations as first-class content work. Model JSON-LD fields, maintain locale-specific files, and let agent skills help with SEO reviews and localized drafts.

Locale workspace
en-USfr-FRde-DE
Locale-first structure

schema/ defines the content model. Here, blog-post.json describes the fields that every blog post item must follow.

content/ stores the actual entries. The blog-post/ folder maps directly to the blog-post schema, and each item inside it is a localized version of the same content item.

assets/ keeps the binary file and its locale-aware metadata together. The .png is the image itself, while the adjacent locale JSON files can hold translated fields such as title, alt text, caption, and other per-locale metadata.

.supatent
schema
blog-post.json
content
blog-post
my-blog-post.en-US.json
my-blog-post.es-ES.json
my-blog-post.de-DE.json
assets
blog-cover-01.png
blog-cover-01.en-US.json
blog-cover-01.es-ES.json
blog-cover-01.de-DE.json
Note

JSON-LD support

Use structured JSON-LD fields for pages, articles, FAQs, software, and other SEO-relevant content models.

Note

Docs from content

Use @supatent/supatent-docs to render documentation from Supatent content in a Next.js app.

Control plane

Agents work in draft. People publish.

Supatent keeps the AI workflow useful without letting it bypass your release process. Drafts can change quickly; published versions are the controlled output your app reads.

Mutable drafts

CLI and app edits target draft content while the team iterates. This is the working state agents and humans update.

Human review
Validate, inspect, then publish.
Published versions

Publishing creates an immutable version for public reads. Your app only consumes the approved output.

Rollback path

A previous published version can be copied back into draft without rewriting the underlying content model.

Structured content

Schemas, content, assets, and locales stay under one project instead of splitting content governance across multiple tools.

FAQ

Common questions

01

How does Supatent work with AI coding agents?

Agents edit Supatent schemas and content as local files. The CLI validates those files and syncs draft changes back to the platform.

02

Can agents publish content directly?

No. The agent workflow is draft-first. Publishing remains an explicit action in Supatent so a person controls what goes live.

03

How do apps read Supatent content?

Use @supatent/client to query published content and assets from your application. Add an API key when you need preview or draft mode during development.

04

What tools are available today?

Use @supatent/cli for file sync, @supatent/client for app integration, @supatent/skills for agent workflows, and @supatent/supatent-docs for rendering docs from Supatent content.

05

How does Supatent help with SEO and localization?

Supatent supports JSON-LD fields, multi-locale content, and SEO-focused skills. Add a locale such as fr-FR, ask your coding agent to translate the content files, validate, and push the draft for review.

Build content workflows your agents can actually use.

Start with the CLI, connect your app with the client package, and keep publication under your control.

View tools