> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gradial.com/llms.txt
> Use this file to discover all available pages before exploring further.

# What is Gradial ACI?

> Agentic Content Infrastructure: the platform where AI agents and humans manage, validate, and publish content through the same governed workflow.

<Info>
  Gradial ACI is currently available to **design partners**. [Request access →](https://www.gradial.com/request-demo)
</Info>

Enterprise content platforms were designed for a world where humans were the only operators. Content lived in vendor databases. Publishing meant hoping nothing broke. And AI was a chatbot bolted onto the side.

**That world is ending.**

AI agents are becoming real operators, drafting pages, optimizing copy, translating content, and generating variants. But they need infrastructure built for them, not retrofitted around them.

Gradial ACI is **Agentic Content Infrastructure**. It is the foundation layer where content is stored, validated, compiled, and published, with AI agents and humans operating through the same workflow, the same governance, and the same audit trail.

## What ACI Owns

ACI is the infrastructure layer beneath your content operations. It owns the full lifecycle from save to publish, with validation at every step.

<CardGroup cols={3}>
  <Card title="Storage & Versioning" icon="database">
    Content stored as immutable versions in your own cloud bucket. Full history, workspaces, and instant rollback built into the storage model.
  </Card>

  <Card title="Validation & Compilation" icon="shield-check">
    Every page validated against its component schema, every reference resolved, every route confirmed before anything goes live.
  </Card>

  <Card title="Publishing & Delivery" icon="rocket">
    Atomic staging, pointer-swap activation, delta rendering, and instant rollback. Content and code coordinated through a single pipeline.
  </Card>
</CardGroup>

## What Gradial ACI Does

ACI manages the entire content lifecycle. Every change is versioned. Every publish is validated. Every rollback is instant.

<CardGroup cols={2}>
  <Card title="Version Everything" icon="code-branch">
    Content is stored as immutable snapshots in your own cloud storage bucket. Every save creates a new version. Every workspace is isolated and safe. Nothing is overwritten.
  </Card>

  <Card title="Validate Before Publish" icon="shield-check">
    A content compiler checks every page against its schema, resolves all references, and builds a dependency graph before anything reaches your users.
  </Card>

  <Card title="Publish Atomically" icon="rocket">
    Publishing stages all affected pages, then flips a single pointer. Your users see the old site or the new site, never a mix. Rollback is the same operation in reverse.
  </Card>

  <Card title="Preview Instantly" icon="eye">
    Preview any combination of code version and content workspace without deploying anything. Change content, refresh, and see the result in under two seconds.
  </Card>

  <Card title="Personalize at the Edge" icon="users">
    Compile multiple content variants per page at build time, one per audience segment, locale, or campaign. The CDN edge routes each user to the right variant with zero runtime latency.
  </Card>
</CardGroup>

## Agents and Humans, Same Interface

ACI treats agents as **first-class operators**. Every agent gets a **draft workspace**, a safe, isolated environment where it can draft, edit, and iterate without affecting production. When the work is ready, it publishes through the same validation pipeline as any human edit.

The interface is designed for the way state-of-the-art AI coding agents already work. No heavyweight MCPs or proprietary APIs to integrate. Agents operate on a **plain filesystem with JSON files**, versioned through **workspaces and snapshots**, and validated through a **linter-inspired compilation step** that gives structured, actionable feedback. This is the environment coding agents are optimized for. ACI meets them there.

For marketers and content teams, this changes what's possible. Instead of learning to navigate CMS menus and configuration screens, authors can direct AI agents using natural language. Describe what you want. The agent drafts it, validates it, and submits it for review. The infrastructure handles the rest.

<CardGroup cols={2}>
  <Card title="Draft Workspaces" icon="code-branch">
    Agents work in isolated draft workspaces. They can make dozens of changes, preview the results, and submit when ready, without risk to production content.
  </Card>

  <Card title="Full Audit Trail" icon="scroll">
    Every change is traceable to the agent or person who made it. Who changed what, when, and why, all the way back to the first version.
  </Card>
</CardGroup>

**This is what "agent-native" means.** Infrastructure designed from the ground up so that agents can safely operate at scale, and authors can focus on what they want to say rather than how to say it in a CMS.

## How It Fits Together

ACI sits between your content operations and your live website. It is the system of record for content, and the system of delivery for your frontend.

```mermaid theme={null}
flowchart TD
    A["Content Authors & AI Agents"] --> B["Gradial ACI"]
    B --> C["Content Compiler"]
    C --> D["Preview (instant)"]
    D -->|"iterate"| A
    C --> E["Publish (atomic)"]
    E --> F["Your Website"]
    G["Your Frontend Repo\n(Astro / Next.js / SvelteKit)"] --> B

    style B fill:#6366f1,color:#fff
    style C fill:#8b5cf6,color:#fff
```

Your frontend code stays in your repository. ACI builds it, understands its components, and renders content through it, without owning or locking in your code.

## What Makes ACI Different

<AccordionGroup>
  <Accordion title="Your data lives in your cloud storage bucket" icon="database">
    ACI stores content as immutable JSON objects in a storage bucket you own. Not a proprietary database. Not a vendor's cloud. Your bucket, your data, your backups. If you leave, you take everything with you.
  </Accordion>

  <Accordion title="Nothing reaches users unvalidated" icon="shield-check">
    The content compiler validates every page against its component schema, resolves every reference, and confirms every dependency before publishing. Broken links, missing translations, and schema mismatches are caught before they go live, not after.
  </Accordion>

  <Accordion title="Content and code are independent but coordinated" icon="arrows-split-up-and-left">
    Content editors and developers work independently. Content is versioned in ACI. Code is versioned in your Git repository. At publish time, ACI brings them together, rendering only what changed, through your actual frontend components.
  </Accordion>

  <Accordion title="Built for frameworks you already use" icon="layer-group">
    ACI ships with adapters for Astro, Next.js, and SvelteKit today. Adding support for additional frameworks is straightforward since ACI's contract is a component registry and a config file, not a deep framework integration. More adapters are coming soon. No framework lock-in, no proprietary templating language.
  </Accordion>
</AccordionGroup>

## The Gradial Platform

Agentic Content Infrastructure (ACI) is the infrastructure layer. On top of it, **Gradial's agentic marketing platform** provides the AI agents that actually operate on your content: drafting pages, optimizing copy, managing translations, running accessibility audits, and generating personalization variants.

<CardGroup cols={3}>
  <Card title="Gradial ACI" icon="server">
    The infrastructure. Content versioning, validation, compilation, preview, and publishing.
  </Card>

  <Card title="Gradial Agents" icon="robot">
    Specialized AI operators that draft, optimize, translate, and audit content through ACI's governed workflow.
  </Card>

  <Card title="Your Frontend" icon="code">
    Your Astro, Next.js, or SvelteKit project. ACI builds it, renders through it, and never locks it in.
  </Card>
</CardGroup>

ACI works without Gradial Agents. You can use it as pure infrastructure with your own tools and workflows. But together, they form a complete agentic content platform where marketers direct agents, developers own the frontend, and ACI guarantees nothing goes live unvalidated.

***

*Next: [How Gradial ACI Works →](/aci/getting-started/how-aci-works)*