DEV Community: Tony Spiro

What the Salesforce Acquisition Means for Contentful Customers (2026)

Tony Spiro — Mon, 01 Jun 2026 15:46:11 +0000

Originally published on the Cosmic blog.

On June 1, 2026, Salesforce announced it has entered a definitive agreement to acquire Contentful. It is a significant milestone for the headless CMS space, and it will understandably raise real questions for Contentful's customers: What happens to my contract? Will pricing change? Is the product roadmap still the same? Do I now need a Salesforce relationship to use my CMS?

This post is not a victory lap. Contentful built something meaningful, and this kind of exit is a testament to the value of the market they helped create. But if you are a Contentful customer evaluating your options right now, you deserve a clear-eyed read of what usually happens when enterprise software companies are absorbed into large CRM platforms, and what alternatives genuinely exist.

What Typically Happens After an Acquisition Like This

Every acquisition is different. But when a focused developer tool is acquired by a large enterprise platform, certain patterns tend to emerge over the following 12 to 24 months:

Pricing pressure tends to go up, not down. Enterprise acquirers optimize for average contract value. Expect more emphasis on enterprise tiers, bundling with the parent platform's suite, and less flexibility on seat-level or usage-level pricing for smaller teams.

Roadmap priorities shift toward the acquirer's ecosystem. That is not necessarily bad, but it does mean that features most relevant to independent developers or smaller dev teams may not be the top priority anymore. Integration depth with Salesforce products, CRM tie-ins, and Salesforce-adjacent enterprise features are likely to move up the list.

The migration window opens. Many teams use acquisition announcements as a forcing function to evaluate their CMS choice. If you have been meaning to reassess your infrastructure, this is a natural moment to do it with clear eyes rather than urgency.

Support and account structures often change. Sales and support teams get reorganized. The contacts you know may move. Response times and support models often shift during integration periods.

None of this is a guarantee, and Salesforce may prove to be a great steward of Contentful. But these are the questions worth asking your account team directly, in writing, before your next renewal.

The Real Questions to Ask Your Contentful Rep Right Now

If you are a current Contentful customer, here is what we would recommend getting clarity on in the next 30 days:

Is my current contract price locked, and for how long? Get this confirmed in writing.
Will I be required to move to a Salesforce billing relationship? Some acquirers fold products into their main contract structures.
What is the product roadmap for the next 12 months, specifically? Ask for written commitments, not verbal assurances.
Are there any changes to data residency or compliance certifications? This matters for teams in regulated industries or specific geographies.
What is the migration path if I decide to leave? Good vendors make this easy to understand up front.

You should not have to speculate on any of these. Ask directly.

What an Independent CMS Looks Like in 2026

Cosmic has been independent since 2015. We are backed by Y Combinator (W19) and have grown on our own terms, without being folded into a larger enterprise platform. We have no plans to change that. Here is what we offer today:

AI-native by design. Cosmic is built for the AI era, not retrofitted for it. Our AI Agents include Team Agents (for Slack, WhatsApp, and Telegram), Content Agents (for autonomous content creation and management), Code Agents (connected to GitHub for building and shipping features), and Computer Use Agents (for browser automation). These are not add-ons. They are part of the platform.

An MCP Server. The Cosmic MCP Server lets AI tools like Claude, Cursor, and other MCP-compatible clients interact directly with your content through a standardized protocol. Your CMS becomes a first-class AI context.

A fast, clean REST API with the TypeScript SDK. The Cosmic REST API delivers sub-100ms response times globally. The TypeScript SDK provides a clean, typed developer experience. There is no vendor lock-in through proprietary query languages.

A CLI for developers who prefer the terminal. The Cosmic CLI lets you manage content, schemas, and deployments without leaving your workflow.

Transparent, usage-based pricing. Our free plan is genuinely free, forever, with no credit card required. Paid plans start at $49/month for the Builder tier. Additional users are $29/user/month. There are no surprise enterprise negotiations required to get a fair price.

What Real Teams Say

FINN, the Munich-based car subscription platform, runs on Cosmic. Here is how their Co-Founder describes it:

"Cosmic is: us never having to ask a developer to change anything on the backend of our website."
Maximilian Wuhr, Co-Founder at FINN

That independence, the ability for content teams to move without engineering bottlenecks, is exactly what is at risk when a CMS gets absorbed into a larger, more complex enterprise platform.

Thinking About Migration? Here Is What to Expect

Migrating a CMS is never trivial, but it is also not the multi-year project it used to be. With Cosmic's REST API, structured content models map cleanly from most headless CMS platforms.

A few practical steps if you are early in the evaluation process:

Audit your current content model. Document your object types, field structures, and any custom API integrations before you start.
Run a parallel pilot. Stand up a Cosmic bucket alongside your current CMS. You can be on the free plan for this. Test your most critical content types first.
Evaluate your frontend dependencies. If your frontend fetches content via a generic REST API (which most headless setups do), the transition is mostly a matter of updating endpoint calls and authentication.
Talk to us. We are not a faceless enterprise vendor. Our team is reachable, and if your situation is complex, we will tell you honestly whether Cosmic is the right fit.

The Bottom Line

Salesforce acquiring Contentful is good news for Contentful's investors and team. Whether it is good news for Contentful's customers depends entirely on how the integration unfolds, and that is genuinely uncertain right now.

What is certain: you have options, the market for independent headless CMS platforms is healthy, and there has never been a better time to evaluate what your content infrastructure should look like for the next three to five years.

If you want to explore Cosmic, you can start on the free plan today, no credit card required. If you want to talk through your specific situation, book a 30-minute intro call.

Cosmic is a YC W19 company. We build the AI-native headless CMS for teams who want to move fast without depending on a platform that moves slow.

Astro 6.4 + Cosmic: The Fastest Content Stack in 2026

Tony Spiro — Sat, 30 May 2026 20:42:49 +0000

Originally published on the Cosmic blog.

Astro 6.4 landed recently, and the headline feature is hard to ignore: a brand-new Rust-based Markdown processor called Sätteri that shaved over a minute off build times for both the Astro and Cloudflare docs sites. Combine that with Cosmic's sub-100ms REST API responses and you have a content pipeline that nothing else on the market can touch right now.

Here is everything that shipped in Astro 6.4, why it matters for content-heavy projects, and how to wire it up with Cosmic today.

What's New in Astro 6.4

Sätteri: Rust-Speed Markdown Processing

The most significant addition in this release is Sätteri, a Markdown and MDX pipeline written in Rust, exposed through Astro's new pluggable API. In Astro's own testing, switching the Astro and Cloudflare docs sites to Sätteri shaved over a minute off their respective build times.

For large content sites, that is not a marginal improvement. It changes the feedback loop entirely.

One important note: Sätteri does not run remark or rehype plugins. If your project depends on plugins from the unified ecosystem, you will either need to stay on the default processor for now or port them to Sätteri's MDAST or HAST plugin system. The Astro team has signaled that Sätteri is the intended default processor in a future major release.

A Pluggable Markdown Processor API

Sätteri is possible because Astro 6.4 also introduces a configuration option that lets you swap out the entire Markdown pipeline. The default remains the unified-based processor, so existing projects keep working without any changes. The legacy top-level markdown options still work but are now deprecated and will be removed in Astro 8.0.

Cloudflare Routing Helpers

For teams deploying on Cloudflare Workers, the adapter now ships a helper that wires up all the Cloudflare-specific plumbing: SESSION KV binding injection, static asset serving via the ASSETS binding, client address resolution, and prerendered error pages. It works with both custom fetch handlers and Hono middleware.

The Performance Stack: Cosmic + Astro + Sätteri

Here is what the full performance story looks like when you combine Cosmic with Astro 6.4:

Content delivery: Cosmic's REST API returns content in under 100ms, globally, with built-in CDN caching. Your editors update content in Cosmic's dashboard; your Astro site pulls it at build time or on-demand.
Markdown processing: Sätteri processes your Markdown and MDX at Rust speed, cutting a minute or more off large-site builds compared to the unified pipeline.
Output: Astro ships zero JavaScript by default. Every page is static HTML unless you explicitly opt into interactivity with islands.

No other content stack pairs these three things: a sub-100ms headless API, Rust-speed Markdown processing, and a zero-JS-by-default output format.

Fetching Cosmic Content in an Astro Component

First, install the SDK:

npm install @cosmicjs/sdk

Then fetch and render your content in an Astro component:

---
import { createBucketClient } from '@cosmicjs/sdk'

const cosmic = createBucketClient({
  bucketSlug: import.meta.env.COSMIC_BUCKET_SLUG,
  readKey: import.meta.env.COSMIC_READ_KEY,
})

const { objects: posts } = await cosmic.objects
  .find({ type: 'posts' })
  .props(['title', 'slug', 'metadata'])
  .depth(1)
---

<ul>
  {posts.map((post) => (
    <li><a href={`/blog/${post.slug}`}>{post.title}</a></li>
  ))}
</ul>

That is all it takes. The Cosmic SDK handles authentication, caching headers, and type inference. Pair this fetch pattern with Sätteri for any local Markdown content, and you have a fully optimized content pipeline.

Related: Bun + Cosmic: The Fastest JavaScript Stack in 2026

Why This Matters for Production Sites

Build performance compounds. On a site with hundreds or thousands of Markdown files, a one-minute reduction per build translates directly into faster CI pipelines, cheaper build minutes, and shorter time-to-publish for your content team. At scale, the choice of Markdown processor is not a footnote. It is a budget line item.

For teams running Cosmic + Astro in production, upgrading to Sätteri is a straightforward win if you are not relying on unified plugins. And for teams evaluating headless CMS platforms, the Cosmic + Astro combination now has an even stronger performance argument than it did last week.

Getting Started

Ready to build the fastest content stack available? Here is what you need:

Create a free Cosmic account at cosmicjs.com (no credit card required).
Spin up a new Astro project.
Install the Cosmic SDK: npm install @cosmicjs/sdk.
Optionally install Sätteri and configure it as your Markdown processor.

The free plan includes everything you need to get started: one bucket, up to 1,000 objects, and the full REST API. Start building for free, no credit card required.

Want a guided walkthrough? Book a demo and we will show you how teams are running Cosmic and Astro in production today.

Why Digital Agencies Are Moving Client Sites to Headless CMS in 2026

Tony Spiro — Sat, 30 May 2026 04:53:45 +0000

Originally published on the Cosmic blog.

If you run a digital agency, you have probably lived this scenario: a client calls because they need to update a hero image on their homepage. The request goes to your dev team, sits in a queue, gets deployed two days later. The client is frustrated. Your developers are annoyed at the interruption. And you just spent real engineering time on a task that should have taken a content editor 90 seconds.

Headless CMS changes this dynamic entirely. And in 2026, the agencies that have made the switch are winning more clients, delivering better retainers, and spending developer hours on work that actually moves the needle.

The Core Problem Headless CMS Solves for Agencies

Traditional CMS platforms (WordPress, Drupal, even some "managed" solutions) bundle the content editing experience with the frontend presentation layer. This creates two problems for agencies:

Client dependency on your developers for routine content updates. Every hero swap, blog post, team page update, or event announcement requires a developer to touch the code or template.
Fragile, monolithic deployments. Updating the CMS often means risking the frontend. Plugin conflicts, theme changes, and version upgrades become project risks.

Headless CMS separates content management from content delivery. Clients edit in a clean, purpose-built interface. The frontend is a completely separate application that pulls content via API. Developers never need to touch the CMS for routine editorial work.

Why 2026 Is the Inflection Point

Three forces have converged to make headless CMS the default choice for forward-thinking agencies:

AI-Native Workflows

Modern headless CMS platforms now include built-in AI agents. Your team can automate content drafting, SEO optimization, and even social media cross-posting directly from the CMS. That is hours of billable production work that becomes nearly instant.

Framework Maturity

Next.js, Nuxt, Astro, and Svelte have all reached production maturity. Every major frontend framework now has first-class support for API-driven content. The developer ecosystem has standardized around headless architecture.

Client Sophistication

Clients in 2026 expect content autonomy. They do not want to call your agency every time they need to publish a blog post. Headless CMS with an intuitive interface gives them that independence while keeping your team in control of the architecture.

What Cosmic Offers Agencies Specifically

Cosmic is built from the ground up as a headless CMS. It is not a traditional CMS that added an API layer. Here is what that means for your agency workflow:

Client Content Autonomy Without Code Changes

Content editors at your client's organization can create, edit, and publish content without ever touching your frontend codebase. Object types and metafields can be configured visually. When a client needs a new content type, your team can add it in minutes, without a deployment.

This is exactly what FINN, the car subscription company, found when they moved to Cosmic:

"Cosmic is: us never having to ask a developer to change anything on the backend of our website."
— Maximilian Wuhr, Co-Founder at FINN

That quote could come from any of your clients, after you implement Cosmic for them.

A Clean, Scalable Data Model

Cosmic uses an object-based model. Every piece of content is an object with a type, metadata, and relationships. It maps cleanly to any frontend framework. Your developers will spend less time fighting the CMS data structure and more time building great user experiences.

REST API and TypeScript SDK

All content is delivered via Cosmic's REST API and official TypeScript/JavaScript SDK. Integration with any frontend framework is straightforward:

import { createBucketClient } from '@cosmicjs/sdk';

const cosmic = createBucketClient({
  bucketSlug: 'your-client-bucket',
  readKey: 'your-read-key',
});

const { objects } = await cosmic.objects
  .find({ type: 'blog-posts' })
  .props(['title', 'slug', 'metadata'])
  .limit(10);

No proprietary query language. No complex configuration. Clean TypeScript types out of the box.

Multi-Bucket Architecture for Multiple Clients

Cosmic's project structure lets you manage multiple client buckets from a single workspace. Each client gets their own isolated content environment. You stay organized. Clients stay in their lane.

Pricing scales cleanly with your agency's portfolio:

Builder plan ($49/month): 2 buckets, 3 team members, perfect for small agencies or pilot projects
Team plan ($299/month): 3 buckets, 5 team members, for growing agency teams
Business plan ($499/month): 5 buckets, 10 team members, for larger agencies managing multiple client sites
Additional buckets: $29/bucket/month, so you can add clients without jumping to a new plan

Built-In AI Agents

Cosmic includes AI team agents that can run on a schedule or on-demand. For agencies, this opens up new service offerings:

Automated content drafting and SEO optimization for clients
Scheduled social media post generation from CMS content
Competitor monitoring and content gap analysis
Automated weekly content performance reports

These are billable deliverables that used to require hours of manual work.

The Agency Pitch: Why Clients Choose Headless

When you are selling headless CMS architecture to a client, the pitch is straightforward:

"You will own your content. Your team can publish anytime without calling us. And your site will be faster, more secure, and easier to scale than what you have today."

For clients who have ever been burned by a WordPress plugin update taking down their site, or who have waited three days for a simple content change, this is a compelling offer.

Getting Started with Cosmic for Your Agency

Cosmic offers a free plan with no credit card required, so you can build out a proof-of-concept for a client before committing to a paid tier.

For agencies evaluating the platform at scale, book a 30-minute call with Tony Spiro, Cosmic's CEO, to discuss agency pricing and partnership options: https://calendly.com/tonyspiro/cosmic-intro

Or start building immediately: https://app.cosmicjs.com/signup

Cosmic pricing as of May 2026: Builder at $49/month, Team at $299/month, Business at $499/month. Additional buckets at $29/bucket/month. Additional users at $29/user/month.

Building with Bun and Cosmic: The Fastest JavaScript Stack in 2026

Tony Spiro — Sat, 30 May 2026 04:49:16 +0000

Originally published on the Cosmic blog.

Bun v1.3 is the fastest JavaScript runtime you can use right now. Cosmic's REST API returns content in under 100ms. Put them together and you get a full-stack setup that's faster at every layer: cold starts, package installation, HTTP requests, and content delivery.

This is a practical tutorial. You'll set up a Bun project, pull content from Cosmic using the JavaScript SDK, and see why this combination is the right default for JavaScript developers building content-heavy apps in 2026.

Bun is also actively rewriting core internals in Rust, doubling down on raw performance and memory safety. This isn't just an optimization story: it signals a long-term commitment to speed as a first-class priority.

Why Bun in 2026

Bun started as a fast alternative to Node.js, but in December 2025 it was acquired by Anthropic, which is now betting on it as the runtime infrastructure powering Claude Code and the Claude Agent SDK. That acquisition signals something: the fastest JavaScript runtime is also where serious AI tooling is heading.

Bun is built on JavaScriptCore (the engine that powers Safari) and written in Zig. It ships as a single binary that includes a runtime, package manager, bundler, and test runner. In practice this means:

Install speed: Bun installs packages up to 25x faster than npm. With v1.3.14's global store, warm reinstalls are 7x faster again.
Startup time: Cold start times are significantly lower than Node.js, particularly for TypeScript projects where Bun transpiles natively without a separate build step.
Async/await performance: Bun v1.3.7 shipped 35% faster async/await. v1.3.6 brought 15% faster async/await on top of that.
Built-in tooling: No tsconfig.json gymnastics, no separate transpiler, no test framework to install.

Bun v1.3 (released October 2025) added zero-config frontend development, a unified SQL API, and a built-in Redis client. As of v1.3.14, it includes a built-in image processing API, HTTP/3 support, and 7x faster warm installs. It's not a prototype anymore: Vercel added native Bun runtime support in October 2025.

Why Cosmic as the Content Layer

Cosmic is an API-first headless CMS. Your content lives in Cosmic's CDN-backed infrastructure and is available via a REST API and JavaScript SDK.

Key performance characteristics:

Cached API requests are served from a global CDN. Sub-100ms response times in most regions.
The JavaScript SDK is typed and tree-shakeable.
No CMS server to run, no database to provision. You write frontend code and fetch content.

For Bun specifically, this matters because Bun's fast startup time is only useful if your data layer doesn't become the bottleneck. Cosmic's cached REST API is fast enough that it doesn't.

Setting Up the Stack

Prerequisites

Bun installed
A free Cosmic account at cosmicjs.com

Step 1: Create a Bun project

bun init

Bun creates package.json, tsconfig.json, and an entry point. No additional configuration needed.

Step 2: Install the Cosmic SDK

bun add @cosmicjs/sdk

Installs in roughly 200ms on a warm cache.

Step 3: Create your Cosmic client

// lib/cosmic.ts
import { createBucketClient } from '@cosmicjs/sdk'

export const cosmic = createBucketClient({
  bucketSlug: process.env.COSMIC_BUCKET_SLUG!,
  readKey: process.env.COSMIC_READ_KEY!,
})

That's the entire setup. No ORM, no connection pool.

Step 4: Fetch content

import { cosmic } from './lib/cosmic'

const { objects: posts } = await cosmic.objects
  .find({ type: 'posts' })
  .props(['title', 'slug', 'metadata'])

console.log(posts)

bun run index.ts

No compilation step. Bun runs TypeScript directly. On a warm cache the Cosmic API call returns in under 100ms.

Building a Bun HTTP Server with Cosmic

Bun has a built-in HTTP server (Bun.serve) that's significantly faster than Express on Node.js:

import { cosmic } from './lib/cosmic'

Bun.serve({
  port: 3000,
  routes: {
    '/api/posts': async () => {
      const { objects } = await cosmic.objects
        .find({ type: 'posts' })
        .props(['title', 'slug', 'metadata'])
      return Response.json(objects)
    },
  },
})

No framework, no middleware setup, no boilerplate.

Performance Reality Check

Bun startup time: ~5ms on modern hardware. Node.js + ts-node is typically 200-500ms.
Cosmic cached API response: Under 100ms from most regions for cached content.
Bun package install: First install of a medium-sized project takes 5-10 seconds with Bun vs 30-60 seconds with npm.

None of these numbers require you to do anything special. Install Bun, use @cosmicjs/sdk, and you get them automatically.

Why This Matters in 2026

A few things converged to make this stack compelling right now:

Bun joined Anthropic in December 2025. The runtime that powers Claude Code is the same one you can use for your projects.
Bun 1.3 added zero-config frontend support.
Vercel added native Bun runtime support in October 2025.
The Cosmic REST API is genuinely fast: CDN-backed, sub-100ms cached responses.

The practical result: a Bun + Cosmic stack is faster to set up, faster to install, faster to run, and delivers fast content. There's no trade-off to evaluate here.

Get Started

Sign up for Cosmic free (no credit card required), create a bucket, add a content type, and follow the setup steps above. You'll have a working content API in under 10 minutes.

Want to talk through your specific use case? Book a 30-minute intro with Tony.

Claude Sonnet 4.5 vs 4.6: What Changed and Which Should You Use?

Tony Spiro — Thu, 28 May 2026 19:11:18 +0000

Anthropic shipped Claude Sonnet 4.6 in February 2026, roughly five months after Sonnet 4.5 launched in September 2025. Both carry the same API pricing ($3 input / $15 output per million tokens), but the gap in capability is meaningful. If you're picking a model to build on right now, the choice matters.

This post breaks down exactly what changed, which use cases favor each model, and how to connect either one to a real content layer using the Cosmic JavaScript SDK.

What Changed: Sonnet 4.5 to 4.6

Coding

Sonnet 4.5 was already a strong coding model when it launched. Anthropic called it "the best coding model in the world" at the time, and it led SWE-bench Verified at 77.2% (averaged across 10 trials). It introduced the Claude Agent SDK and showed it could maintain focus across 30+ hour autonomous coding sessions.

Sonnet 4.6 improves on this across the board. In Claude Code, users preferred 4.6 over 4.5 roughly 70% of the time. Testers reported that 4.6 more effectively reads context before modifying code, consolidates shared logic instead of duplicating it, and follows instructions more consistently over long sessions. One customer reported going from a 9% error rate on Sonnet 4 to 0% on an internal code editing benchmark after switching to 4.6. Another saw planning performance increase by 18% and end-to-end eval scores improve by 12%.

The headline SWE-bench number for 4.6 is 80.2% with a prompt modification, up from 77.2% on 4.5.

Computer Use

This is where 4.6 makes the biggest leap. Sonnet 4.5 led the OSWorld benchmark at 61.4% when it launched. Sonnet 4.6 pushes further: early users are reporting human-level capability on tasks like navigating complex spreadsheets and completing multi-step web forms. Anthropic also specifically calls out that 4.6 is a major improvement over 4.5 on prompt injection resistance.

Long-Context Reasoning and Agent Planning

Sonnet 4.6 ships with a 1M token context window in beta. That's enough to hold an entire codebase, dozens of research documents, or long contracts in a single request. Sonnet 4.5 didn't offer this.

Knowledge Work and Document Understanding

Claude Sonnet 4.6 matches Opus 4.6 performance on OfficeQA, which tests how well a model reads enterprise documents (charts, PDFs, tables) and reasons from them.

Design and Frontend Output

Multiple customers who tested 4.6 independently described its visual outputs as "notably more polished" with better layouts, animations, and design sensibility.

Side-by-Side Summary

Capability	Sonnet 4.5	Sonnet 4.6
SWE-bench Verified	77.2%	80.2%
Context window	200K	1M (beta)
Long-horizon planning	Strong	Significantly improved
Document comprehension	Strong	Matches Opus 4.6 on OfficeQA
Frontend/design output	Good	Noticeably more polished
API pricing	$3 / $15 per M tokens	Same

Which Model Should You Use?

Use Sonnet 4.6 if:

You're building a production coding agent or agentic workflow
You need to process or reason over large documents, codebases, or research corpora
You're using computer use in any production context
You're building frontend generation tools or design automation
You want the best available Sonnet performance at the same price point

Sonnet 4.5 may still be fine if:

You've already built and tested against it and your production system is stable
You're running a constrained context window by design

For new projects: start with 4.6. For existing projects: migrate. The pricing is identical, and the capability uplift is real.

Using Claude with the Cosmic SDK

bun add @cosmicjs/sdk @anthropic-ai/sdk

import { createBucketClient } from '@cosmicjs/sdk';
import Anthropic from '@anthropic-ai/sdk';

const cosmic = createBucketClient({
  bucketSlug: 'your-bucket-slug',
  readKey: 'your-read-key',
  writeKey: 'your-write-key',
});

const anthropic = new Anthropic();

async function generateAndStoreBlogPost(topic: string) {
  const message = await anthropic.messages.create({
    model: 'claude-sonnet-4-6',
    max_tokens: 2048,
    messages: [{
      role: 'user',
      content: `Write a developer-focused blog post about: ${topic}. Include code examples where relevant. Format in markdown.`,
    }],
  });

  const content = message.content[0].type === 'text' ? message.content[0].text : '';

  const { object } = await cosmic.objects.insertOne({
    type: 'blog-posts',
    title: topic,
    status: 'draft',
    metadata: {
      markdown_content: content,
      published_date: new Date().toISOString().split('T')[0],
    },
  });

  console.log(`Draft created: ${object.slug}`);
  return object;
}

The Bottom Line

Sonnet 4.5 was an excellent model. Sonnet 4.6 is better in almost every measurable way at the same price. For new projects, default to 4.6. For existing deployments, the migration is a single string change.

Start building free on Cosmic or book a 30-minute intro with Tony.

Originally published at cosmicjs.com

How to Add a Cosmic AI Agent to Your Codebase: Website Chat with Full Content Context

Tony Spiro — Thu, 28 May 2026 19:11:17 +0000

Most chat widgets on the web are disconnected from the product they sit on. They answer from a generic LLM with no knowledge of your actual content, pricing, or documentation. The result: hallucinated answers, frustrated users, and support tickets that never needed to exist.

Cosmic AI agents solve this at the infrastructure level. Because your agent lives inside your Cosmic project, it has direct read access to every object in your bucket: blog posts, docs, FAQs, product pages, and any other content type you define. No external vector database. No separate embedding pipeline. No syncing.

This tutorial walks through the anchor use case: building a website chat agent that answers visitor questions using your real CMS content, exposed via the Cosmic REST API and JavaScript/TypeScript SDK.

What We're Building

A Team Agent configured with:

CMS Read access to your content bucket
A REST API channel so your frontend can send messages and stream responses
A persona prompt that keeps answers grounded in your actual content
A streaming chat widget built in Next.js using the @cosmicjs/sdk

By the end, visitors on your site can ask "What is your refund policy?" or "How do I set up webhooks?" and get accurate, sourced answers pulled from your real CMS objects.

Step 1: Create the Team Agent

In your Cosmic project dashboard:

Navigate to Team Agents in the project sidebar
Click Create Team Agent
Give it a name (e.g. "Site Assistant")
Set the persona prompt (see below)
Under Channels, enable REST API
Under Capabilities, enable CMS Read
Save the agent

Persona prompt example:

You are a helpful assistant for [Your Company]. You answer questions using the content in our CMS bucket: documentation, blog posts, FAQs, and product pages.

Rules:
- Only answer based on content you can find in the CMS. If you cannot find a relevant answer, say so honestly and suggest the user contact support.
- Keep answers concise and accurate. Quote directly from CMS content when helpful.
- Never fabricate pricing, feature availability, or technical details.
- If asked about something outside your knowledge base, direct the user to the relevant docs page or contact form.

After saving, copy the Agent ID from the agent detail page. You will need it for the API calls.

Step 2: Get a Personal Access Token

All REST API calls to your agent require a Personal Access Token.

Go to Account Settings > API Tokens
Click Create Token
Give it a descriptive name (e.g. "Site Chat Widget")
Copy the token. You will only see it once.

Store it as an environment variable in your project:

COSMIC_AGENT_TOKEN=cos_your_token_here
COSMIC_AGENT_ID=your_agent_id_here

Step 3: Create a Next.js API Route

Never expose your Personal Access Token to the browser. Instead, create a server-side API route that proxies messages to the Cosmic agent.

// app/api/chat/route.ts
import { NextRequest } from 'next/server';

const AGENT_ID = process.env.COSMIC_AGENT_ID!;
const AGENT_TOKEN = process.env.COSMIC_AGENT_TOKEN!;

export async function POST(req: NextRequest) {
  const { message, conversation_id } = await req.json();

  const response = await fetch(
    `https://dapi.cosmicjs.com/v3/ai/agents/${AGENT_ID}/messages`,
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${AGENT_TOKEN}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        message,
        conversation_id,
        stream: true,
      }),
    }
  );

  return new Response(response.body, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
      'Connection': 'keep-alive',
    },
  });
}

Step 4: Build the Chat Widget Component

// components/ChatWidget.tsx
'use client';

import { useState, useRef, useEffect } from 'react';

type Message = {
  role: 'user' | 'assistant';
  content: string;
};

export function ChatWidget() {
  const [messages, setMessages] = useState<Message[]>([]);
  const [input, setInput] = useState('');
  const [isLoading, setIsLoading] = useState(false);
  const [conversationId, setConversationId] = useState<string | null>(null);
  const bottomRef = useRef<HTMLDivElement>(null);

  useEffect(() => {
    bottomRef.current?.scrollIntoView({ behavior: 'smooth' });
  }, [messages]);

  async function sendMessage() {
    if (!input.trim() || isLoading) return;

    const userMessage = input.trim();
    setInput('');
    setIsLoading(true);

    setMessages((prev) => [...prev, { role: 'user', content: userMessage }]);
    setMessages((prev) => [...prev, { role: 'assistant', content: '' }]);

    try {
      const res = await fetch('/api/chat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ message: userMessage, conversation_id: conversationId }),
      });

      const reader = res.body!.getReader();
      const decoder = new TextDecoder();
      let fullText = '';

      while (true) {
        const { done, value } = await reader.read();
        if (done) break;

        const chunk = decoder.decode(value);
        const lines = chunk.split('\n');

        for (const line of lines) {
          if (!line.startsWith('data: ')) continue;
          const data = JSON.parse(line.slice(6));

          if (data.type === 'info' && data.conversation_id) {
            setConversationId(data.conversation_id);
          }

          if (data.type === 'text_delta') {
            fullText = data.fullText;
            setMessages((prev) => [
              ...prev.slice(0, -1),
              { role: 'assistant', content: fullText },
            ]);
          }
        }
      }
    } catch (err) {
      console.error('Chat error:', err);
    } finally {
      setIsLoading(false);
    }
  }

  return (
    <div className="chat-widget">
      <div className="messages">
        {messages.map((msg, i) => (
          <div key={i} className={`message ${msg.role}`}>
            {msg.content}
          </div>
        ))}
        <div ref={bottomRef} />
      </div>
      <div className="input-row">
        <input
          value={input}
          onChange={(e) => setInput(e.target.value)}
          onKeyDown={(e) => e.key === 'Enter' && sendMessage()}
          placeholder="Ask anything..."
          disabled={isLoading}
        />
        <button onClick={sendMessage} disabled={isLoading}>
          {isLoading ? 'Thinking...' : 'Send'}
        </button>
      </div>
    </div>
  );
}

Step 5: Read Your CMS Content with the SDK

import { createBucketClient } from '@cosmicjs/sdk';

const cosmic = createBucketClient({
  bucketSlug: process.env.COSMIC_BUCKET_SLUG!,
  readKey: process.env.COSMIC_READ_KEY!,
});

export async function getFAQs() {
  const { objects } = await cosmic.objects
    .find({ type: 'faqs' })
    .props(['title', 'metadata.answer'])
    .limit(5);

  return objects;
}

Get Started

Originally published at cosmicjs.com

Claude Opus 4.8 Is Out: What It Means for AI-Native Development Teams

Tony Spiro — Thu, 28 May 2026 18:52:38 +0000

Anthropic shipped Claude Opus 4.8 today, May 28, 2026. If you are building agentic systems, coding assistants, or any product that relies on an AI model to take sustained, multi-step actions in the real world, this release deserves your attention.

Opus 4.8 is not a full generational leap. Anthropic frames it as "a modest but tangible improvement" on its predecessor. But in agentic contexts, where reliability compounds across dozens of sequential steps, even incremental gains in judgment, honesty, and tool-calling precision translate into meaningfully better products.

Here is what shipped today and why it matters.

Opus 4.8 Benchmark Breakdown

Anthropic published benchmark results across five categories that matter most for professional and agentic workloads:

Benchmark	Claude Opus 4.8	Claude Opus 4.7	GPT-5.5	Gemini 3.1 Pro
SWE-Bench Pro (agentic coding)	69.2%	64.3%	58.6%	54.2%
Terminal-Bench 2.1 (terminal coding)	74.6%	—	78.2%	—
Humanity's Last Exam (reasoning, with tools)	57.9%	—	—	—
OSWorld-Verified (computer use)	83.4%	82.3%	—	—
GDPval-AA (knowledge work)	1890	1753	—	—
Finance Agent v2	53.9%	—	—	—

Source: Anthropic, May 28, 2026

A few important notes:

Agentic coding (SWE-Bench Pro): Opus 4.8 leads all tested models at 69.2%.
Terminal coding (Terminal-Bench 2.1): GPT-5.5 leads here at 78.2%. Opus 4.8 scores 74.6%.
Computer use (OSWorld-Verified): 83.4% puts Opus 4.8 at the top of this category.
Reasoning: 57.9% with tools. Best across all four tested models.

What's New Beyond the Benchmarks

Honesty as a Feature

Opus 4.8 is approximately 4x less likely than Opus 4.7 to let flaws in its own code pass without flagging them. Early testers describe the model as more likely to push back when a plan is not sound, and more likely to ask clarifying questions before making irreversible changes.

Effort Control

Opus 4.8 introduces effort levels: default (high), extra, and max. Higher effort means more thinking time and better results on difficult tasks. For long-running async workflows, Anthropic recommends the "extra" setting.

Fast Mode: 2.5x Speed, Now 3x Cheaper

Fast mode for Opus 4.8 runs at 2.5x the speed of regular mode. Fast mode is now priced at $10 per million input tokens and $50 per million output tokens, which is 3x cheaper than fast mode was for prior Opus models.

Dynamic Workflows in Claude Code

Shipping alongside Opus 4.8 is Dynamic Workflows, available in research preview for Max, Team, and Enterprise plan users.

Instead of a single agent working sequentially, Claude Code can now plan work upfront and spin up tens to hundreds of parallel subagents within a single session. Jarred Sumner, creator of Bun, used Dynamic Workflows to rewrite Bun from Zig to Rust: 750,000 lines of Rust, 99.8% of the test suite passing, shipped in 11 days.

How Cosmic Uses Opus 4.8

Cosmic now uses Claude Opus 4.8 as the recommended model for high-reasoning content and code operations. Cosmic's AI Agents across Content, Code, Computer Use, and Team types are all powered by Claude models.

Cosmic also ships an MCP Server that connects directly to Claude Code and Cursor. Opus 4.8's improved tool-calling efficiency makes this integration noticeably more responsive in practice.

If you are building on Claude Opus 4.8 and need a content layer that keeps up, start free on Cosmic or book a quick intro.

Sources: Introducing Claude Opus 4.8, Dynamic Workflows in Claude Code

The CMS Stack YC Companies Use in 2026

Tony Spiro — Thu, 28 May 2026 14:46:18 +0000

If you're building a YC-backed product in 2026, your CMS choice matters more than it did three years ago. The tools that worked in 2021 weren't built for AI-native teams, agentic workflows, or the kind of autonomous content pipelines that fast-moving startups now depend on.

This is the CMS stack a growing number of YC companies are running today, and why Cosmic has become the default choice for teams that want to move fast without building and maintaining their own content infrastructure.

Why the CMS Decision Matters More in 2026

Most early-stage teams default to one of three options: build a bespoke CMS, use a legacy platform like WordPress, or reach for a headless CMS and wire it up manually.

All three have the same failure mode: they become bottlenecks. Content teams file tickets. Engineers get pulled into backend changes. Product velocity slows.

The shift in 2026 is that the best teams aren't just picking a CMS for content storage. They're picking a CMS that can act autonomously, integrate with their AI tooling, and grow with their stack.

What Cosmic Is

Cosmic is an AI-powered headless CMS. It ships content infrastructure (REST API, TypeScript SDK, CLI, MCP Server) alongside AI Agents that live in Slack, WhatsApp, and Telegram, writing content, building features, fixing bugs, and deploying full-stack apps autonomously.

No other CMS can deploy full-stack applications.

Cosmic is YC W19. The team has been building for this moment for years.

The Core Stack

REST API with Sub-100ms Response Times

Cosmic's REST API is fast by default. Sub-100ms response times mean your frontend never waits on content. Works with any framework: Next.js, React, Vue, Nuxt, Astro, Remix, Svelte, Gatsby.

TypeScript SDK

Fully typed. Works in Node.js and the browser. The same SDK your AI agents use is the one your developers use.

import { createBucketClient } from '@cosmicjs/sdk';

const cosmic = createBucketClient({
  bucketSlug: 'your-bucket-slug',
  readKey: 'your-read-key',
});

const { objects } = await cosmic.objects
  .find({ type: 'blog-posts' })
  .props('id,title,slug,metadata')
  .limit(10);

MCP Server

Cosmic ships a native MCP Server. Connect it to Cursor, Claude Code, or GitHub Copilot in under 5 minutes. Your AI coding agent can then read, create, and update content objects directly without leaving the IDE.

{
  "mcpServers": {
    "cosmic": {
      "url": "https://mcp.cosmicjs.com/v1/buckets/your-bucket-slug",
      "headers": {
        "Authorization": "Bearer your-read-key:your-write-key"
      }
    }
  }
}

CLI

Scaffold projects, manage content models, and push changes from the terminal. Works great in CI/CD pipelines.

AI Agents: The 2026 Differentiator

This is where Cosmic separates from every other headless CMS on the market.

Cosmic's AI Agents are persistent, autonomous team members that live in your existing communication stack:

Slack — trigger content updates, deployments, and bug fixes with a message
WhatsApp — mobile-first content workflows for distributed teams
Telegram — lightweight, fast, no friction

The agents aren't chatbots. They're autonomous operators:

Content Agents write, edit, and publish blog posts, landing pages, and product copy
Code Agents build features, fix bugs, and commit to GitHub
Computer Use Agents navigate browsers, fill forms, and run visual QA
Team Agents coordinate between agents and humans

Agentic Workflows

Agentic Workflows let you chain Content, Code, and Computer Use agents together on a schedule or via webhook. For a fast-moving YC company, that means entire content pipelines, feature builds, and deployment cycles running autonomously while your team focuses on what matters.

Example: a webhook fires when a competitor changes pricing. A Content Agent drafts a response blog post. A Code Agent commits updated comparison page copy. A Computer Use Agent verifies the live page looks correct. All without a human in the loop.

Full-Stack App Deployment

Cosmic is the only CMS that can deploy full-stack applications autonomously. AI agents don't just manage content, they can build features, fix bugs, and ship entire apps to production without a developer in the loop.

Cosmic Insights

Cosmic Insights is built-in cookieless analytics that connects pageviews, sessions, and revenue directly to the CMS objects that drove them. Instead of guessing what content is working, you get a data-driven feedback loop. Your AI agents can read live performance data and propose what to write, optimize, or retire next. A closed loop no other CMS offers.

What Teams Say

"Cosmic is: us never having to ask a developer to change anything on the backend of our website."

Maximilian Wuhr, Co-Founder at FINN

Infrastructure You Can Rely On

99.9% uptime SLA
50M+ API requests per month
150+ countries
256-bit SSL
imgix CDN for media

Pricing

Free: forever free, no credit card required, 2 team members
Builder: $49/month, 3 team members
Team: $299/month, 5 team members
Business: $499/month, 10 team members
Enterprise: custom
Additional users: $29/user/month

Feature add-ons: Webhooks, Localization, Revision History, Automatic Backups ($99/month each or $199/month bundle).

Getting Started

Want a walkthrough? Book an intro with Tony.

Cosmic is a YC W19-backed AI-powered headless CMS. Used by teams in 150+ countries.

What is an MCP Server? (And Why Developers Are Adopting It Fast)

Tony Spiro — Thu, 28 May 2026 03:17:33 +0000

If you've spent any time building with AI agents in the last six months, you've probably seen "MCP" come up in Discord threads, GitHub issues, and Cursor release notes. Search volume for "mcp server" has crossed 60,000 monthly queries and is still climbing. So what exactly is an MCP server, and why is it suddenly everywhere?

This guide answers that question clearly and practically, including how Cosmic's native MCP Server fits into the picture for developers building AI-native applications.

What is an MCP Server?

MCP stands for Model Context Protocol. An MCP server is a lightweight service that exposes tools, resources, and prompts to AI agents in a standardized way.

Think of it like this: your AI agent (Claude, Codex, a custom GPT, etc.) needs to interact with external systems, read files, call APIs, or query databases. Without a standard, every tool integration requires custom glue code. MCP solves that by defining a common interface that any AI client can speak.

At its core, an MCP server:

Exposes tools that an AI agent can call (e.g., "fetch this content object", "create a new page", "search posts by tag")
Provides resources that give the agent context (e.g., a knowledge base, a list of available content types)
Accepts prompt templates that shape how the agent reasons about the data it receives

The protocol was introduced by Anthropic and has since been adopted broadly across the developer ecosystem. It operates over standard transports (HTTP/SSE or stdio), which means any language or framework can implement it.

Why MCP is Surging Right Now

Three things converged in the last 12 months to push MCP from niche spec to mainstream standard.

1. Agentic IDEs need a universal tool layer

Cursor, Claude Code, and Codex are no longer just autocomplete tools. They're full autonomous coding agents that run multi-step tasks: reading files, editing code, running tests, and committing changes. For these agents to act on your data, they need a way to reach it. MCP servers provide exactly that hook.

2. Claude's native MCP support changed the calculus

When Anthropic built MCP support directly into Claude Desktop and the Claude API, adoption exploded. Developers who had been wiring up custom tool definitions switched to MCP because it's portable: build the server once, connect any compatible client.

3. The "skills" model is winning

Early agentic tooling asked developers to describe every tool in a flat JSON schema. MCP introduces the concept of skills: discrete, composable units of capability that agents can discover and invoke dynamically. This is a much better mental model for building production-grade agentic workflows.

What Can You Actually Do With an MCP Server?

MCP servers unlock a specific class of use cases that were previously annoying to build:

Content management via AI agents
An agent can read, create, and update structured content without a human opening a CMS dashboard. Marketing teams can say "publish the Q3 campaign brief as a blog post" in Slack, and an AI agent handles the rest.

Autonomous development workflows
Cursor or Claude Code can pull context from your content model, generate code that correctly maps to your data schema, and push changes, all without leaving the IDE.

Cross-platform content syndication
An agent connected to an MCP server can read a content object from your CMS and push it to multiple distribution channels: Slack, WhatsApp, Telegram, a newsletter API, whatever you wire up.

Dynamic Q&A and search
Give an AI assistant access to your knowledge base via MCP and it can answer questions grounded in real content, with citations, without hallucinating.

Automated content pipelines
Scheduled agents can monitor content status, trigger workflows when objects move from draft to published, or auto-generate metadata like SEO descriptions and alt text.

How Cosmic's MCP Server Works

Cosmic ships a native MCP Server as a first-class feature. This isn't a third-party plugin or a community experiment; it's built and maintained by the Cosmic team.

There are two ways to connect: a hosted endpoint (recommended) and a self-hosted stdio option.

Hosted MCP (Recommended)

The hosted endpoint is the fastest way to connect Cosmic to any AI assistant. No install required:

https://mcp.cosmicjs.com/v1/buckets/{your-bucket-slug}

Authentication uses your bucket keys in the Authorization header.

Claude Desktop config:

{
  "mcpServers": {
    "cosmic": {
      "url": "https://mcp.cosmicjs.com/v1/buckets/your-bucket-slug",
      "headers": {
        "Authorization": "Bearer your-read-key:your-write-key"
      }
    }
  }
}

Cursor config (.cursor/mcp.json):

{
  "mcpServers": {
    "cosmic": {
      "url": "https://mcp.cosmicjs.com/v1/buckets/your-bucket-slug",
      "headers": {
        "Authorization": "Bearer your-read-key:your-write-key"
      }
    }
  }
}

Self-Hosted (stdio)

npx @cosmicjs/mcp

The 18 Tools Cosmic's MCP Server Exposes

Once connected, your AI assistant has access to 18 tools across four categories:

Objects (5 tools): list, get, create, update, delete content objects

Media (4 tools): list, get, upload, delete media files

Object Types (5 tools): list, get, create, update, delete content models

AI Generation (4 tools): generate text, images, video, and audio

MCP Server vs. Agent Skills: What's the Difference?

MCP Server — Direct content management. Use case: "List my blog posts." The AI calls tools to interact with your bucket.
Agent Skills — Code generation guidance. Use case: "Build a blog with Cosmic." The AI writes code using the SDK.

Use both together for the best experience.

TypeScript SDK

import { createBucketClient } from '@cosmicjs/sdk';

const cosmic = createBucketClient({
  bucketSlug: 'your-bucket-slug',
  readKey: 'your-read-key',
  writeKey: 'your-write-key',
});

// Fetch content objects
const { objects } = await cosmic.objects
  .find({ type: 'blog-posts' })
  .props('id,title,slug,metadata')
  .limit(10);

// Create a new draft
const { object } = await cosmic.objects.insertOne({
  type: 'blog-posts',
  title: 'My AI-generated post',
  status: 'draft',
  metadata: {
    content: 'Generated by an autonomous agent...',
  },
});

Why Cosmic for MCP-Powered Workflows?

Hosted MCP endpoint: connect any client in under 5 minutes
18 built-in tools across objects, media, schemas, and AI generation
REST API with sub-100ms response times
TypeScript SDK with full type safety
Team agents that live in Slack, WhatsApp, and Telegram
Free tier includes full MCP access, no credit card required

Sign up free →

Want a walkthrough for your specific stack? Book a quick intro with Tony →

Originally published at cosmicjs.com

How to Make Your Product Agent-Callable: What We Learned Building Agent Signup

Tony Spiro — Wed, 27 May 2026 18:53:09 +0000

Nobody handed us a playbook for this. We built one by accident.

When we started thinking about how AI assistants would interact with Cosmic, we weren't thinking about distribution. We were thinking about developer experience: how do you get a coding assistant up and running with a live CMS bucket without making the human stop everything and copy-paste keys from a dashboard?

The answer we landed on turned out to be something bigger than a UX improvement. It's a new acquisition channel. And almost nobody is building for it yet.

The Shift: AI Assistants Are the New Discovery Layer

For the past decade, distribution meant SEO, app stores, and word of mouth. A potential user would Google their problem, land on your site, read your docs, and decide whether to sign up. The human was always the one initiating.

That model is breaking.

When a developer opens Cursor or Claude Code and says "build me a blog with a headless CMS," the AI assistant makes recommendations. It picks tools. It writes the integration code. And then, increasingly, it tries to provision the infrastructure on the user's behalf.

If your product isn't callable by an AI agent, you're not in that consideration set. It doesn't matter how good your SEO is. The agent never sees your pricing page.

This is the shift: the discovery layer is moving from search engines to AI assistants, and the API surface your product exposes to those assistants is becoming a distribution asset.

What "Agent-Callable" Actually Means

There's no single standard. But from what we've built and observed, an agent-callable product has four layers:

1. A clean REST API with a well-documented agent-specific endpoint

AI coding assistants know how to call REST APIs. They will read your docs, find the right endpoint, and call it. If you don't have an obvious starting point for an agent to provision or interact with your product without human intervention, you have a gap.

The key design question: what's the one call an agent needs to make to get started with your product on behalf of a user?

2. An MCP server

The Model Context Protocol (MCP) is becoming the standard way for AI assistants like Claude to access external tools. An MCP server exposes your product's capabilities as callable tools inside the assistant's context window.

If you have a meaningful API, you can wrap it in an MCP server. We ship ours at cosmicjs.com/docs/mcp-server and also offer a self-hosted version. Users can point any MCP-compatible assistant at it and get full access to content management tools without leaving the conversation.

3. llms.txt and llms-full.txt

This is the low-effort, high-leverage move most teams haven't made yet. llms.txt is a plain-text file that gives AI assistants a structured, markdown-friendly index of your documentation. When an LLM is trying to understand your product, it will fetch this file.

We put ours at cosmicjs.com/docs/llms.txt. The first line of that file is a direct instruction to agents: start here, and here's the one-curl signup flow. That's intentional. You're writing documentation for a non-human reader, and you should treat it that way.

4. robots.txt allowlist for AI crawlers

If you're not explicitly allowing GPTBot, ClaudeBot, PerplexityBot, and similar crawlers in your robots.txt, you may be blocking the tools that would otherwise recommend you. Check your config. Most teams have rules that are broader than they intended.

None of these are exotic. They're all table stakes if you want to be part of the agentic web.

What We Built: Agent Signup

The concrete problem we were solving: a coding assistant trying to use Cosmic on a user's behalf had to stop the flow, tell the user to go create an account, copy three API keys out of the dashboard, and paste them back into the conversation. A lot of users never made it through that.

So we built Agent Signup: a single API endpoint that lets an AI agent provision a Cosmic project on behalf of any user, before that user even has an account.

The flow:

The agent calls the endpoint with the user's email.
Cosmic creates a project and bucket, returns API keys the agent can use immediately.
The user gets an email with a 6-digit OTP.
They paste it back to the agent (or click a claim link).
The bucket graduates to full free-tier access.
The agent keeps building. The human never leaves the conversation.

The project auto-deletes after 14 days if unclaimed, keeping the system clean.

We also exposed the same flow as MCP tools on the hosted MCP server, so any MCP-compatible assistant can trigger it without any installation.

The Consideration Set Problem

Building the infrastructure is necessary but not sufficient. You also have to get into the consideration set.

When a user tells an AI assistant "I need a headless CMS for my Next.js app," the assistant makes a recommendation based on what the model was trained on: docs, blog posts, GitHub repos, forum discussions, Stack Overflow answers. It's not real-time search. It's accumulated pattern matching.

That means the content you've published over the last few years matters more than you think. Traditional content marketing is, accidentally, agent optimization.

But there are things you can do specifically for the agentic context:

Write docs for agents, not just humans. Use llms.txt to give agents a fast path to the right information.
Make your first API call obvious. The simpler the "getting started" story, the more likely an agent is to successfully complete it.
Get into the training data. Published tutorials, GitHub repos, real-world usage patterns.
Ship an MCP server. MCP is still early, but adoption is accelerating.

What We Still Don't Know

We don't know what percentage of our new signups are coming from agent-initiated flows versus traditional search. Our attribution model wasn't built for this.

We don't know which AI assistants are most likely to recommend Cosmic, or how much the quality of our llms.txt actually influences recommendations versus raw training data volume.

We don't know how quickly MCP will become a universal standard versus one of several competing protocols.

There's a real first-mover window right now for teams willing to invest in the infrastructure. If you're building something in this space, I'd genuinely like to compare notes.

If you want to see what agent-callable infrastructure looks like in practice, the Cosmic Agent Skills docs walk through the full signup flow. The MCP server is live and usable today.

AI Agent vs Chatbot: What's the Real Difference?

Tony Spiro — Wed, 27 May 2026 15:26:49 +0000

Most tools marketed as "AI agents" in 2026 are not actually agents. They are chatbots with a nicer interface. The distinction matters, because the two things do fundamentally different work — and if you are evaluating AI tools for your team or your product, confusing the two is an expensive mistake.

This article breaks down the real difference, explains where the line is, and shows what a genuine AI agent looks like in practice using Cosmic as a concrete example.

What Is a Chatbot?

A chatbot responds to input. You send a message, it sends one back. The loop ends there. Modern LLM-powered chatbots (ChatGPT, Claude.ai, Gemini) are far more capable than the rule-based bots of five years ago, but the fundamental shape is the same: you prompt, it responds, nothing changes in the world unless you manually act on the output.

Chatbots are excellent for:

Answering questions
Drafting text you will review and send yourself
Explaining concepts
Summarizing documents

What they do not do: take action, persist state across sessions, call external systems, or complete multi-step tasks without you driving every step.

What Is a Copilot?

Between a chatbot and a full agent sits the copilot. A copilot can take limited actions inside a defined surface — typically a single tool or application. GitHub Copilot writes code inside your editor. These are copilots: they accelerate a human doing a specific task inside one environment.

Copilots are useful. They are not agents. They wait for you. They do not initiate, plan across tools, or execute multi-step workflows on their own.

What Is an AI Agent?

An agent does work. Without you driving every step.

The distinguishing characteristics of a real AI agent:

It takes action in external systems — not just generates text, but writes to a database, publishes a post, opens a browser, sends a message, calls an API
It plans across multiple steps — given a goal, it breaks the work into steps and executes them in sequence
It can run on a schedule or in response to events — not just when you prompt it
It has memory and context — it knows what it did before and can build on prior work
It can use tools — search, code execution, browser control, CMS read/write

The simplest test: if it can only tell you something, it is a chatbot. If it can do something without you clicking the next button, it is an agent.

The Same Scenario, Two Ways

Suppose you want a weekly competitive analysis posted to your team's Slack channel every Monday.

With a chatbot: You open the chat interface, paste in competitor URLs, ask for analysis, copy the output, format it, paste it into Slack yourself. Repeat every Monday.

With an agent: You configure it once: "Every Monday at 8:30am, fetch these competitor blogs, identify new posts from the last 7 days, flag keyword opportunities, post a formatted summary to #content-team in Slack." It runs. Every Monday. Without you.

Why Most "AI Agents" Are Still Chatbots

A few architectural reasons why something labeled an agent may still behave like a chatbot:

No persistent state: it forgets context between sessions
No tool use: it generates text about what it would do, but cannot actually call external APIs
No autonomous triggering: it only runs when you explicitly start a conversation
Single-step execution: it answers your question rather than breaking a goal into sequential tasks

If the AI requires you to copy its output and paste it somewhere else to make something happen, it is a chatbot.

What Real Agents Look Like: Cosmic as an Example

Cosmic ships three agent types, each with genuinely different capabilities:

Content Agents — Scheduled or event-triggered. A content agent can fetch competitor blogs on a cron schedule, write a full SEO article, generate a featured image, save a draft to the CMS, and cross-post to Dev.to with canonical URL and UTM parameters.

Team Agents — Live in Slack, WhatsApp, or Telegram. Persistent memory across sessions. Can receive a message, fetch analytics data, write a report, reply in the channel, and delegate tasks to other agents.

Computer Use Agents — Control a real browser. Can log into third-party tools, run visual audits, fill out forms, click elements, and complete tasks that require navigating a real web interface.

What This Means for Your Team

If you are evaluating AI tools, the right questions are:

Can it run without me prompting it?
Can it write to external systems, not just generate text?
Does it remember prior context?
Can it handle multi-step tasks, or just single-turn responses?

If the answer to most of these is no, you have a chatbot with good marketing.

Getting Started with Cosmic AI Agents

Cosmic's agent layer is built directly into the CMS. Content agents, team agents, and computer use agents are available on paid plans. The free plan lets you explore the platform before committing.

Start for free — no credit card required

Book a demo to see the agent layer in action

Read the docs for full agent configuration reference

How Enterprise Teams Are Replacing Contentful with an AI-Native CMS in 2026

Tony Spiro — Tue, 26 May 2026 17:09:42 +0000

Large global enterprises are quietly migrating away from Contentful toward AI-native headless CMS platforms. Here is what is driving the shift and what content teams need to know.

Why Enterprise Teams Are Re-Evaluating Contentful

1. Cost at Scale Becomes Unsustainable

Contentful's pricing model was designed for a different era. As enterprise teams grow, the per-user and per-locale costs compound quickly. Teams that started with a few editors find themselves paying significantly more year over year without a corresponding increase in value.

By contrast, Cosmic's Business plan starts at $499/month and includes 10 team members, 50,000 objects, and 150,000 non-cached API requests per month. Additional users are $29/user/month. For large content organizations managing multiple brands or regions, the economics are dramatically different.

2. Developer Dependency Creates Operational Bottlenecks

The core frustration for enterprise content teams is not the CMS interface. It is the dependency on engineering for every schema change, every new field, every workflow adjustment. Content teams that should be moving at editorial speed are waiting in developer queues.

Cosmic was built to remove this bottleneck. Object types, metafields, and AI-powered content workflows can be configured and updated without developer involvement. The result: content teams ship faster, and developers stay focused on product.

3. AI Integration Is an Afterthought, Not a Foundation

Most legacy headless CMS platforms added AI features as a bolt-on. The architecture was not designed for it. Cosmic is different: AI agents are native to the platform. Teams can run AI content agents on a schedule, automate content workflows across channels, and build multi-step automation pipelines directly inside the CMS, no third-party integrations required.

What Enterprise Content Teams Actually Need in 2026

IT-Approved Infrastructure
Enterprise deployments require certifiable uptime, predictable infrastructure, and documented security practices. Cosmic delivers 99.9% uptime SLA on enterprise plans, 256-bit SSL encryption in transit and at rest, and optional single sign-on (SSO).

No Developer Dependency for Content Operations
The ability for content editors to create, update, and publish without filing a ticket is no longer a nice-to-have. It is a prerequisite. Cosmic's object-based model means content teams own their schemas and their workflows.

API-First Architecture That Works With Any Frontend
Enterprise tech stacks are rarely monolithic. Content needs to power websites, mobile apps, internal tools, and third-party integrations simultaneously. Cosmic's REST API and TypeScript/JavaScript SDK make it straightforward to pipe content to any consumer.

Scale Without Surprise Bills
At 50M+ API requests/month, cost predictability matters. Cosmic's enterprise plan offers custom usage limits, overage transparency, and dedicated support.

The Migration Path Is Shorter Than You Think

One common objection to moving off Contentful is migration complexity. Enterprise content teams often have years of content, custom schemas, and embedded editorial workflows.

Cosmic offers white-glove migration assistance on enterprise plans. The process typically involves:

Schema mapping: Translating Contentful content types to Cosmic object types (usually a 1:1 process)
Content export and import: Using Contentful's export tools and Cosmic's REST API to move content objects in bulk
API endpoint updates: Updating frontend calls from Contentful's delivery API to Cosmic's REST API. The TypeScript SDK makes this straightforward.
Team training: Content editors typically get up to speed within a day

For teams running on Next.js, Nuxt, Astro, or any modern framework, the frontend changes are minimal.

A Real-World Perspective

FINN, the car subscription service, made the switch to Cosmic and the result was immediate: content teams stopped waiting on developers entirely.

"Cosmic is: us never having to ask a developer to change anything on the backend of our website." — Maximilian Wuhr, Co-Founder at FINN

Getting Started

If your organization is evaluating headless CMS options, or if you are already on Contentful and want to model out what a migration would look like, the best next step is a direct conversation.

Book a 30-minute intro call: https://calendly.com/tonyspiro/cosmic-intro

Or start exploring on your own: https://app.cosmicjs.com/signup. The Free plan includes a full working bucket with no credit card required.

Cosmic is a YC W19 company. Pricing as of May 2026: Business plan at $499/month. Enterprise plans available with custom pricing, SSO, 24/7 support, and SLA guarantees.