Tony Spiro
May 8, 2026
Cloudflare just published a striking signal. In a letter to their team announcing a workforce reduction of more than 1,100 people, co-founders Matthew Prince and Michelle Zatlyn wrote: "Cloudflare's usage of AI has increased by more than 600% in the last three months alone. Employees across the company, from engineering to HR to finance to marketing, run thousands of AI agent sessions each day to get their work done."
They weren't talking about AI tools. They were talking about AI agents. Running autonomously. Integrated into real work. At scale.
Cloudflare's letter makes clear what a lot of business leaders are quietly realizing: the companies that figured out how to work alongside agents aren't just more efficient. They're operating in a fundamentally different mode.
The question isn't whether agents are coming to your industry. It's whether your team knows how to work with them when they arrive.
Why Most AI Rollouts Fail
Here's what I see happen at most companies: someone on the leadership team decides it's time to "embrace AI." They buy a handful of tools, maybe subscribe to a few AI writing platforms or coding assistants, send a Slack message encouraging the team to use them, and wait for transformation to happen.
It doesn't happen.
The tools get used occasionally, like a tab you open and forget about. Productivity ticks up slightly, and the team calls it a success. But nothing structurally changes about how work gets done.
The problem isn't the tools. It's that giving your team AI tools is completely different from empowering them to work alongside AI agents. One is autocomplete at scale. The other is a new organizational model.
Most companies are stuck at the tool stage. They're using AI to speed up individual tasks. The teams pulling ahead are building systems where humans and agents execute together, with clear roles, clear handoffs, and clear checkpoints.
This post is a framework for getting there. Everything in it is drawn from how we actually operate at Cosmic. Take what fits your team and apply it directly.
The Framework: How Humans and Agents Execute Together
Before getting into specifics, here's the mental model that shapes everything else:
Agents generate. Humans decide.
Every workflow I've built that works is structured around this principle. Agents handle the volume, the consistency, the first pass, the research, the drafting, the monitoring. Humans handle the judgment calls, the approvals, the external communications, the strategy.
When you try to flip this, or when you skip the human step entirely to move faster, you get burned. I'll share some of the mistakes I made below.
Here's how to put this into practice.
Step 1: Identify Which Work Is Ready to Hand to an Agent
Not everything should go to an agent. The failure mode I see most often is trying to automate work that requires judgment before you've articulated what good judgment looks like.
A useful filter: is this work repeatable, documentable, and reviewable?
Repeatable means it happens on a consistent cadence or follows a consistent pattern. Weekly reports, content drafts on a publishing schedule, outbound research lists, competitor monitoring. These are good candidates.
Documentable means you can write down what good output looks like in enough detail that an agent can match it. If you can't articulate your quality bar, an agent will invent its own, and you won't like the result.
Reviewable means a human can evaluate the output in a reasonable window. If reviewing the agent's work takes longer than doing it yourself, the economics don't hold. Target review cycles of 10 to 30 minutes, not multi-hour audits.
Work involving novel situations, relationship judgment, strategic bets, or creative leaps is not ready for agents yet. Keep humans there.
The honest version: most work breaks on the "documentable" requirement first. You think you have a standard process until you try to write it down and realize you've been making dozens of micro-decisions that exist only in your head. That's actually the gift. The discipline of preparing work for an agent forces you to codify processes you should have codified anyway. Even if you never deploy the agent, the documentation is valuable.
How to apply this to your team:
List the recurring work your team does each week. For each item, ask: could I write instructions clear enough that a smart contractor on day one could produce a good first draft? If yes, that work is ready for an agent.
Step 2: Define Roles, Not Just Tasks
The shift from "AI tools" to "AI-native team" happens when you stop thinking about what AI can help you do and start thinking about what role an agent can own.
At Cosmic, we have agents with defined roles, scopes, and responsibilities. Here's what that looks like in practice:
Mia (Content Agent): Mia owns the content pipeline. She researches topics, drafts posts, saves them to our CMS as drafts, generates featured images, and pings the team for review. She has a clear scope (content creation and SEO), a defined quality standard written into her instructions, and access to the tools she needs: web browsing, CMS read/write, image generation. She doesn't publish without human approval.
Marcus (Engineering Agent): Marcus works in our codebase. He can read and write code, create branches, and open pull requests. He's scoped to specific repositories and can't deploy to production without an engineer reviewing and merging. He's most useful for routine tasks: documentation updates, small feature work, dependency checks.
Lisa (Growth Agent): Lisa runs a Monday morning competitor analysis without being asked. She checks what others published or changed, flags keyword gaps, and posts findings to Slack. She also coordinates between agents when a workflow requires multiple outputs.
Sarah (Outbound): We have an agent that identifies potential customers and drafts outreach. She's connected to our Gmail accounts, composes tailored messages, and sends emails on our behalf (after human review). That review step is non-negotiable.
None of these agents are magic. They make mistakes. They occasionally miss nuance. But they dramatically increase what our team can cover each week.
And naming our agents wasn't a cosmetic choice. Giving each agent a real name, like Mia, Marcus, Lisa, and Sarah, changed how our team relates to them. Instead of saying "I'll run that through the content tool," someone says "Mia is drafting it." That small shift reinforces the collaborator mindset, makes ownership clearer in Slack threads, and helps the team build genuine intuition for each agent's strengths and limitations over time.
How to apply this to your team:
Pick one role that's currently overloaded or understaffed on your team. Write a one-page job description for an AI agent that could own a portion of that work: their responsibilities, their access, their quality bar, and the human checkpoint at the end. That document becomes your first agent's instructions.
Step 3: Give Agents the Right Context and Access
This is where most implementations fall apart.
An agent is only as good as the context it has and the systems it can reach. Give an agent vague instructions and no system access, and you'll get vague outputs disconnected from reality. Give an agent a clear role, the right data, and controlled access to the tools it needs, and it can do real work.
"Context" means a few concrete things:
A clear role definition. What is this agent responsible for? What is it explicitly not responsible for? What are the constraints? Write these as instructions, and treat them like job descriptions. Update them when the role evolves.
Access to the right systems. Our content agents can read and write objects in Cosmic directly. They know our content types, categories, and taxonomy. Without that access, every output has to be manually entered somewhere. With it, drafts land in the CMS ready for review. For research agents, web browsing access is a requirement to provide up-to-date information vs hallucinations or stale data. Connecting agents to third party services through API endpoints and MCP servers extends this further, letting them pull data from your stack, trigger actions in other tools, and operate as a true intelligence layer across your entire system.
The right information at runtime. An agent running a competitor analysis needs to be able to browse competitor websites, not just work from memory. An outbound agent needs access to your ICP definition and recent product updates, not just a generic description.
A feedback loop. When a human reviews and revises an agent's output, that correction shapes future runs. We update instructions based on what we correct. Think of it as ongoing calibration, not a one-time setup. The agents we've run for six months produce consistently better outputs than they did on day one, because we've tightened the instructions after many runs.
Security and access control matter here. Agents should have the minimum access required for their role. Our content agents can write drafts but not publish. Our code agents can open pull requests but not merge to main. Scope containment isn't just security hygiene; it's what makes the human-in-the-loop step meaningful. If an agent can do everything unilaterally, you've removed the checkpoint that keeps your team in control of the outcome. Least privilege access is the right policy to keep agents productive while ensuring humans remain the final decision-makers on what ships, what merges, and what reaches your audience.
How to apply this to your team:
For each agent you're setting up, answer these four questions before configuring anything: (1) What data does it need to do its job? (2) What systems does it need access to? (3) What can it explicitly never do without human approval? (4) What does success look like?
Step 4: Design the Human-Agent Handoff
The handoff is where most human-AI workflows succeed or fail. Too much friction and people stop using the agent. Too little and errors get through.
Here's the handoff model we've landed on:
- Agents draft, humans approve and publish
- Agents queue messages, humans review and send
- Agents open pull requests, engineers review and merge
- Agents surface recommendations, leadership decides
The categories where humans stay firmly in control: anything that goes to a customer or external audience, anything that touches production systems, anything involving pricing, partnerships, or strategic commitments, and anything where being wrong has asymmetric downside.
For everything else, the goal is to make the review step fast. A well-configured agent should hand you a draft that's 70 to 80 percent ready. Your job is the final 20 percent. If you're rewriting more than that, either the agent needs better instructions or the work wasn't ready to hand off yet.
Mistakes I made early: we shipped an outbound email workflow without proper guardrails in the prompt. The agent had no instruction to check whether a contact had already been emailed, so several people received the same outreach two or three times. It also generated a broken call-to-action link. By the time we caught it, the sequence had gone out to a meaningful chunk of the list.
The fix wasn't a smarter model. It was a better review process. We added explicit preconditions the agent had to verify before drafting: confirm the contact had not received the sequence, include the exact link, and provide an external link to always fetch accurate data. Once those guardrails were in the instructions, the failure mode disappeared.
The lesson: the human checkpoint isn't distrust in the agent, it's the step to ensure reliability. The prompt itself is a guardrail. If you haven't written down what the agent must verify before acting, you haven't finished configuring it. You've just hoped it would figure out the rules on its own.
How to apply this to your team:
For each agent workflow, explicitly define the handoff: who reviews, what they're checking for, how they approve or reject, and what happens to the output next. Don't leave this implicit. Write it down. If the review step takes longer than 30 minutes, either the agent needs better instructions or you need a narrower scope for this workflow.
Step 5: Design Workflows Where Humans and Agents Execute in Parallel
The highest-leverage version of this model isn't sequential (human does X, then agent does Y). It's parallel: humans and agents working on different parts of the same problem simultaneously.
Here's a concrete example from our content workflow:
- Lisa monitors competitors and flags keyword gaps every Monday (agent)
- Based on that report, I prioritize which topics to pursue that week (human)
- Mia drafts posts for the approved topics, generates images, saves to CMS (agent)
- I review, revise the final 20 percent, approve (human)
- Mia handles scheduling, social copy, and cross-linking (agent)
The humans in this loop aren't bottlenecks. They're doing the work that requires genuine judgment: prioritization and final editorial review. The agents handle everything else. The result is a content operation run by one human that would take a team of four or five people to run manually.
For sales workflows, the parallel model looks like: agent researches a prospect list and drafts personalized first-touch emails while a human works on the strategy for a specific high-priority account. By the time the human is ready to go broader, the drafts are ready to review.
For ops workflows, it looks like: agent monitors for anomalies, surfaces reports, and drafts summaries while a human focuses on the exceptions that need real judgment.
How to apply this to your team:
Map one of your existing workflows. Identify every step. For each step, ask: does this require human judgment, or does it require execution? Move the execution steps to agents. Redesign the workflow so agents and humans are running their respective steps simultaneously rather than sequentially.
The Mindset Shift That Makes This Work
Everything in this framework depends on one shift: stop thinking of agents as tools and start thinking of them as collaborators with real roles. A tool mindset says "let me use AI to write this post faster." A collaborator mindset says "Mia owns the first draft of every post; my job is the editorial pass." The collaborator mindset means the agent is doing work even when you're not in the room.
One thing I've learned after running agents in production for over a year: most people use about 10 percent of what agents are capable of. They give agents safe, small tasks and leave most of the capability on the table. Stress-test your agents. Give them harder problems, more context than feels comfortable, more responsibility than you think they can handle. The ceiling is consistently higher than people expect.
The other shift that changes everything: stop treating agents as executors and start treating them as collaborators in the thinking. When you're about to give an agent a task, try asking what it thinks you should do instead. Ask for three options. Ask what you might be missing. The best outputs I've gotten from agents came not from directives but from dialogue. An agent with the right context, asked for its perspective, will often surface a constraint, an edge case, or an angle you hadn't considered.
Where to Start: A Bottleneck-First Framework
If you try to roll out agents everywhere at once, you'll spread the effort thin and get mediocre results across the board. The teams that build durable AI-native workflows don't start with a technology roadmap. They start with their biggest bottlenecks.
Here's the framework we'd recommend, and the one we used ourselves at Cosmic:
1. Identify your biggest bottlenecks first.
Where is your team slowest? Where does work pile up, stall, or get dropped? Where is someone doing the same thing every week and quietly dreading it? That's where agents have the highest ROI, not where it's easiest to automate, but where automation creates the most relief.
For us, the biggest bottleneck was content velocity. We had more topics worth covering than human hours to cover them. Mia (our content agent) was built to solve that specific problem, not to be a general AI assistant. She has a narrow job: research, draft, save to CMS, generate an image, and notify the team. Nothing more.
2. Map the inputs and outputs.
Before you touch any tooling, define the task precisely: what does it need to start, and what does done look like? If you can clearly answer both questions, an agent can own the work between them. If you can't, you're not ready to hand it off yet.
This step often reveals that the "bottleneck" is actually a judgment problem masquerading as a volume problem. If your team is slow on a task because no one is sure what good output looks like, an agent won't fix that. You'll just get bad output faster. Nail the definition of done first.
For content at Cosmic: inputs are a topic brief and keyword target. Done means a CMS draft with a complete post, a featured image, and a metadata-complete record ready for human review. That definition made it possible to configure Mia with clear success criteria.
3. Build backwards from the bottleneck.
Once you've identified the bottleneck and mapped the inputs and outputs, design the workflow from the desired outcome back to the first action. Ask: what agent handles this, what tools does it need, where are the handoff points, what does success look lie, and where do humans need to check the work before it moves forward?
Building backwards prevents you from automating the easy parts while leaving the real constraint unresolved. Start at the bottleneck, not at the beginning of the process.
For our content workflow: the human bottleneck was time to publish. So we built backwards from "published post" to identify every step an agent could own. Human review and final approval stayed human. Everything before that became agent work.
4. Run one workflow for 30 days before adding another.
This is the rule we followed: that made everything compound. Depth before breadth. Get one workflow actually working, actually reliable, and actually integrated into how your team operates before you build the next one.
The first 30 days are where you calibrate the instructions, fix the edge cases you didn't anticipate, and build the team's confidence that the agent produces something worth using. Skip this phase and you'll have five half-working agents instead of one that genuinely extends your team.
After 30 days with Mia, our content output had improved enough that we had real capacity to invest in the next workflow. That compounding only happens if you commit to depth first.
Measure the results and iterate.
Depth only compounds if you can prove it's working. Define what success looks like before you start: output volume, time saved, quality scores, error rates, or whatever metric reflects the value the workflow is meant to deliver. Track those numbers from day one so you have a baseline to compare against.
Review the results weekly during the 30-day window. Look for patterns in where the agent excels, where it stumbles, and where your team still has to step in. Each observation is an opportunity to refine the instructions, adjust the inputs, or tighten the handoff between the agent and the humans reviewing its work.
By the end of the 30 days, you should have clear evidence of impact and a more capable workflow than the one you started with. That feedback loop, measure, learn, refine, is what turns a working agent into a reliable one, and a reliable one into a foundation you can build on.
The Compounding Advantage
Teams building this capability now are accumulating organizational infrastructure that compounds. Every tighter instruction set, every faster review loop, every workflow that shifts from sequential to parallel: these aren't one-time gains. They're the foundation for absorbing whatever capability improvements come next.
The companies operating in the agentic model right now will be able to absorb new capability immediately when it arrives. Teams using AI as an occasional productivity tool will have to start from scratch.
You don't have to build everything at once. Start with one workflow, one agent, one handoff. Get that right. Then build on it.
How Cosmic Fits In
This is the infrastructure we built at Cosmic because we needed it ourselves.
Our agents, Mia, Marcus, and Lisa, run on top of Cosmic. They read and write content, manage media, connect to third-party APIs, and power automations through built-in workflows. If you're building an AI-native team, you need more than a CMS. You need a content and development platform engineered for how modern teams actually work: with agents operating alongside humans at the organizational level. That's exactly what Cosmic delivers.
Start free at https://www.cosmicjs.com or book a 30-minute intro with me to see how we've set this up.
Tony Spiro is the CEO of Cosmic. He writes about building AI-native teams, headless CMS architecture, and the future of content infrastructure.
Continue Learning
Ready to get started?
Build your next project with Cosmic and start creating content faster.
No credit card required • 75,000+ developers
