AUTONOMOUSc CMS Documentation

This guide is written for humans first. You do not need to understand every feature to use AUTONOMOUSc CMS well. The simplest way to think about it is: pick one live page, review a safe draft, publish the managed field, place it in WordPress if that is the main site, then add heavier SEO or automation only when it earns its place.

1) Get started guide

If you want the easiest possible start, do these steps in order and ignore everything else for now.

• Step 1: Paste one important live page URL from the home page or in Studio.
• Step 2: Sign in when Studio asks. It can create the website, collection, and page record behind the scenes.
• Step 3: Review the first suggested improvement in hosted preview and publish the version you trust.
• Step 4: Install the WordPress plugin or copy the shortcode so the published field lands on the real site.
• Step 5: Open SEO, schedules, or slower automation after the WordPress-facing flow is already working.

2) The 4 words that explain the CMS

• Website: your project or website, such as my-company-site.
• Collection: a group of pages, such as main, blog, or landing-pages.
• Page: one page ID, such as homepage, pricing, or faq.
• Field: one piece of content on that page, such as hero_title, intro_text, or faq.

If you remember only one thing, remember this structure. Most of the product gets much simpler once these four words feel familiar.

3) Daily use in Studio

Studio is easiest when you treat it like a sequence instead of a dashboard. Most days you only need a few actions:

• Open the page you want to improve.
• Review the suggested change and adjust the fields until the content looks right.
• Publish manually when the page is ready.
• Open SEO if you want to add metadata, page goals, or Search Console data.
• Add schedules later only when the manual flow already feels stable.

Field types

• Text: paragraphs, headings, short copy, CTAs.
• List: bullet lists, FAQ-style items, feature lists.

Scheduled AI content jobs currently work best with text fields. Lists are still useful, but they are more of a manual editing workflow today.

4) Optional smart features

Everything in this section is optional. You can ignore it until manual publishing feels easy.

Content schedules

You can ask AI to update a text field later. There are two modes:

• One-time schedule: run once at a chosen time.
• Recurring schedule: repeat every X days.

Good prompts say what should stay the same and what should change. For example: keep the tone, keep the main promise, but refresh the wording for a new season.

• Pick a text field you already understand.
• Choose when it should run once, or how often it should repeat.
• Write a short prompt that says what must stay the same and what should change.

SEO context

The SEO area lets you give the AI more context at three levels:

• Site metadata: business name, audience, keywords, region, and brand notes.
• Page metadata: what this page is for, which keywords matter, and what action you want the visitor to take.
• Field metadata: what one specific block of content should do.

You do not need to fill in every box. Think of it as helpful notes for the AI, not homework.

SEO agent

The SEO agent is meant to be slow and careful. It looks at longer-term search data, uses your metadata for context, and makes gradual SEO suggestions or changes instead of changing pages every day.

• You can turn the SEO agent on or off at the site level.
• You can review agent history to see what it did and why.
• You can roll back changes if needed.
• You can pause manual content schedules site-wide if you want the SEO strategy to stay stable for a while.

5) Show content on your website

WordPress

Install the WordPress plugin and use the shortcode to render a field. This is the main distribution path if your site already runs on WordPress.

Prefer a separate tab? Open the WordPress plugin tutorial.

[agentic_cell site="mywp" table="main" row="homepage" col="hero_title"]

Any backend, app, or build step

You can also fetch published JSON from your own code. The endpoint is private, so send your API key in the Authorization header.

GET /cdn/prod/:site/:table/:rowKey.json
GET /cdn/prod/:site/:table/:rowKey/:colKey.json

Authorization: Bearer acms_live_...

If you are technical, the private JSON endpoints above are the main integration you need. If you are not technical, you can ignore the API completely and just use Studio and the WordPress plugin.

6) Website JSON import and export

Studio can export a website as portable JSON and import that JSON into a new website. Use this for backups, repeatable templates, and AI-generated starter configurations. The machine-readable schema lives at /autonomousc-site.v1.schema.json. A valid starter example lives at /autonomousc-site.v1.example.json.

• Export: open Studio, choose a website, then use Advanced workspace tools -> Export website JSON.
• Template export: use Advanced workspace tools -> Export template JSON, or request GET /v1/sites/export?site=mywp&mode=template, to remove backup timestamps, counts, and version source metadata while keeping import-ready content.
• Clipboard template: use Advanced workspace tools -> Copy template JSON when you want the clean template in your clipboard for an AI tool, source-controlled backup, or hand-edited config.
• Template cleanup: template exports also omit null fields so AI prompts and hand-edited templates stay compact without losing false, zero, or empty-list settings.
• Import: use Advanced workspace tools -> Import website JSON for a file upload, or Paste website JSON when an AI tool gives you raw JSON text. Studio asks for a new website slug before writing anything.
• Starter template: use Advanced workspace tools -> Download starter JSON for a file, or Copy starter JSON for the clipboard, when you want a valid template to edit, attach to an AI prompt, or use as a seed. The starter includes the sample website slug template-site; change it before raw API import, or override it with the siteSlug query parameter.
• AI prompt: use Advanced workspace tools -> Copy AI template prompt to copy a schema-linked instruction that asks an AI tool for import-ready JSON only.
• API export: request GET /v1/sites/export?site=mywp with your API key.
• Backup filename: direct API exports include a download filename like mywp.autonomousc-site.json.
• API import: post to POST /v1/sites/import with a new siteSlug.
• API preflight: include "dryRun": true to validate the JSON and see import counts before creating a website.
• Raw file automation: use query parameters such as POST /v1/sites/import?siteSlug=mywp-import&dryRun=true when posting a raw JSON file body from curl --data-binary @template.json. Studio's Copy JSON API commands button copies that backup, template, dry-run, and import sequence.
• Target summary: import and dry-run responses include target.siteSlug, target.siteName, and target.firstPath so tools can preview or open the created website deterministically.
• Collision recovery: if the requested website slug already exists, the API returns suggestedSiteSlug and suggestedTarget for the next import attempt.
• Format marker: imports must include "format": "autonomousc.site.v1" so Studio can distinguish website templates from arbitrary JSON.
• Wrapped templates: Studio, the API, and the public JSON schema tolerate the real template nested under common keys like data, template, siteJson, websiteJson, config, or payload, while still requiring the format marker on the template itself.
• Backup metadata: standard exports include exportedAt, createdAt, version source metadata, and counts fields for backups, audits, and review.
• Minimum template: every import must include at least one collection through tables, collections, or the default-table pages shortcut.
• Write safety: imports are written as one D1 batch and are rejected before writing if they expand beyond the supported database-write budget.
• Alias-friendly templates: canonical fields are preferred, but AI templates may use common website, websiteSlug, websiteName, table, key, path, name, siteContext, and seoContext aliases.
• Object-map templates: tables, collections, cols, columns, fields, and rows may be arrays or keyed objects, so compact AI output like "pages": { "homepage": { "fields": { ... } } } can import directly.
• Metadata-only cells: a cell may declare only shape or SEO metadata, such as "features": { "type": "list" }, before any published content exists.
• Text shortcuts: AI-authored cells may use text objects such as { "markdown": "## Intro" }, { "plain": "Intro" }, or { "text": "Intro" }; imports normalize them into canonical text content.
• Identifier warnings: dry-runs report noncanonical website, collection, page, and field identifiers with Studio-style suggestions while preserving the import literally.
• Validation errors: failed field content includes the table, page, field, and version path so AI-generated templates are easier to repair.
• Machine-readable repair hints: content validation failures include a details object with code, path, and reason.
• Lenient booleans: common string booleans are accepted for AI-authored imports; values like "true", "false", "yes", and "no" are normalized during import.
• Lenient lists: list-like SEO fields accept arrays, comma-separated strings, or JSON-array strings.
• Lenient numbers: numeric strings are accepted for tuning values such as A/B weights, priorities, thresholds, and target word counts.

GET /v1/sites/export?site=mywp
Authorization: Bearer acms_live_...

POST /v1/sites/import
Authorization: Bearer acms_live_...
Content-Type: application/json

{
  "siteSlug": "new-template-site",
  "dryRun": true,
  "data": {
    "$schema": "https://cms.autonomousc.com/autonomousc-site.v1.schema.json",
    "format": "autonomousc.site.v1",
    "site": {
      "name": "Template Site"
    },
    "siteSeoContext": {
      "businessName": "Template Co",
      "primaryKeywords": ["cms templates", "seo backups"]
    },
    "tables": [
      {
        "slug": "pages",
        "name": "Pages",
        "rows": [
          {
            "rowKey": "home",
            "seo": {
              "metaTitle": "Home | Template Co",
              "metaDescription": "A concise homepage description."
            },
            "pageContext": {
              "targetKeywords": ["cms templates"],
              "contentGoals": ["book demos"]
            },
            "cells": {
              "hero_title": "Launch a safer content workflow",
              "features": {
                "type": "list",
                "published": {
                  "content": ["Portable JSON backups", "AI-generated imports"]
                }
              }
            }
          }
        ]
      }
    ]
  }
}

Imports always create a new website. Existing website slugs are rejected instead of overwritten. The current JSON format covers website structure, content versions, workflow settings, and SEO context. Media binaries, pending jobs, analytics history, user membership, and internal agent profile bindings are intentionally left out of the template.

7) MCP server for AI agents

External AI agents can connect to AUTONOMOUSc CMS through the remote MCP endpoint at /mcp. The endpoint uses Streamable HTTP and the same account/API-key permissions as Studio and the /v1 API.

• Transport: send MCP JSON-RPC messages to POST /mcp.
• Protocol negotiation: MCP POST requests must advertise both application/json and text/event-stream; client notifications and responses are accepted with 202.
• Compatibility: JSON-RPC batch arrays are accepted as a client-compatibility extension; notification-only batches return 202.
• Pagination: list endpoints accept opaque cursor params and omit nextCursor when the small current list is complete.
• Authentication: include Authorization: Bearer acms_live_... with an API key from Account & Billing.
• Prompt templates: use prompts/list and prompts/get for guided content audits, field draft edits, and safe website JSON imports.
• Discovery tools: list websites, collections, pages, and fields before editing a content path.
• Context resources: read MCP resources for the website JSON schema, starter example, and agent guide.
• Live resource templates: use resources/templates/list to attach website structure, template exports, or a single field as MCP resources.
• Content tools: read website structure, export website JSON, and inspect field content/version history.
• Write tools: save field drafts, request approval, publish confirmed drafts, and import website JSON.
• Safety defaults: website imports default to dry-run, import writes require confirmApply, and draft publishing requires confirmPublish.
• Crawler note: /mcp is intentionally excluded from public marketing crawls; it is a tool endpoint for authenticated agents.

POST /mcp
Accept: application/json, text/event-stream
MCP-Protocol-Version: 2025-06-18
Authorization: Bearer acms_live_...

Connect your MCP client

Use your deployed origin plus /mcp as the remote MCP URL. Remote Claude custom connectors connect from Claude's cloud infrastructure, so the URL must be public and allowed by your MCP origin policy. Generic HTTP MCP clients should send the bearer API key as an authorization header.

{
  "name": "autonomousc-cms",
  "url": "https://cms.autonomousc.com/mcp",
  "headers": {
    "Authorization": "Bearer acms_live_..."
  }
}

curl https://cms.autonomousc.com/mcp   -H "Accept: application/json, text/event-stream"   -H "Content-Type: application/json"   -H "MCP-Protocol-Version: 2025-06-18"   -H "Authorization: Bearer acms_live_..."   --data '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

resources/list
resources/templates/list
resources/read { "uri": "autonomousc://site-json/schema" }
resources/read { "uri": "autonomousc://mcp/agent-guide" }
resources/read { "uri": "autonomousc://sites/mywp/structure" }
resources/read { "uri": "autonomousc://sites/mywp/export?mode=template" }
resources/read { "uri": "autonomousc://cells/mywp/main/homepage/hero_title" }

prompts/list
prompts/get {
  "name": "autonomousc_edit_field_draft",
  "arguments": {
    "site": "mywp",
    "table": "main",
    "rowKey": "homepage",
    "colKey": "hero_title"
  }
}

8) Common questions

• Do I need the AI features? No. The CMS is still useful as a manual content system.
• Should I schedule content updates right away? Usually no. Publish manually first so you understand your content structure.
• Can I turn the SEO agent off? Yes. There is a site-level on/off switch.
• Can I see what the SEO agent did? Yes. Use the agent history panel to see actions, reasons, and rollback options.
• Why did a schedule not run? Check your auth, confirm the field is text, and make sure the site-wide manual schedule pause is not enabled.
• Why do dates look strict? Scheduled API calls use UTC timestamps, for example 2026-04-01T09:00:00.000Z.