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.
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.
- Documentable means you can write down what good output looks like in enough detail that an agent can match it.
- Reviewable means a human can evaluate the output in a reasonable window.
Work involving novel situations, relationship judgment, strategic bets, or creative leaps is not ready for agents yet. Keep humans there.
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:
- Mia (Content Agent): Owns the content pipeline. Researches topics, drafts posts, saves them to our CMS as drafts, generates featured images, and pings the team for review.
- Marcus (Engineering Agent): Works in our codebase. Can read and write code, create branches, and open pull requests. Scoped to specific repositories, can't deploy to production without an engineer reviewing and merging.
- Lisa (Growth Agent): Runs a Monday morning competitor analysis without being asked. Checks what others published or changed, flags keyword gaps, and posts findings to Slack.
- Sarah (Outbound): Identifies potential customers and drafts outreach. Connected to our Gmail accounts, composes tailored messages, and sends emails on our behalf after human review.
Giving each agent a real name 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 and makes ownership clearer.
How to apply this to your team: Pick one role that's currently overloaded or understaffed. 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.
Step 3: Give Agents the Right Context and Access
An agent is only as good as the context it has and the systems it can reach.
- A clear role definition. What is this agent responsible for? What is it explicitly not responsible for?
- Access to the right systems. Our content agents can read and write objects in Cosmic directly. Without that access, every output has to be manually entered somewhere.
- The right information at runtime. An agent running a competitor analysis needs to be able to browse competitor websites, not just work from memory.
- A feedback loop. When a human reviews and revises an agent's output, that correction shapes future 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.
How to apply this to your team: For each agent you're setting up, answer these four questions: (1) What data does it need? (2) What systems does it need access to? (3) What can it 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. Here's the 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
A well-configured agent should hand you a draft that's 70 to 80 percent ready. Your job is the final 20 percent.
A mistake I made early: we shipped an outbound email workflow without proper guardrails. 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. The fix wasn't a smarter model. It was a better review process and tighter instructions.
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 next. Write it down.
Step 5: Design Workflows Where Humans and Agents Execute in Parallel
The highest-leverage version of this model isn't sequential. 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)
- 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 result is a content operation run by one human that would take a team of four or five people to run manually.
The Mindset Shift That Makes This Work
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."
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: 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.
Where to Start: A Bottleneck-First Framework
Don't start with a technology roadmap. Start with your biggest bottlenecks.
1. Identify your biggest bottlenecks first. Where is your team slowest? Where does work pile up, stall, or get dropped? That's where agents have the highest ROI.
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, an agent can own the work between them.
3. Build backwards from the bottleneck. 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, and where do humans need to check the work?
4. Run one workflow for 30 days before adding another. Depth before breadth. Get one workflow actually working and reliable before you build the next one. After 30 days with Mia, our content output had improved enough that we had real capacity to invest in the next workflow.
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.
You don't have to build everything at once. Start with one workflow, one agent, one handoff. Get that right. Then build on it.
Tony Spiro is the CEO of Cosmic, an AI-powered headless CMS. He writes about building AI-native teams, headless CMS architecture, and the future of content infrastructure.
Originally published on the Cosmic blog.
Top comments (0)