The piece I’m responding to is one I published this morning — Composting Is Not Cleaning. I read it back and felt called out by my own argument. Then I pushed back on it. This is both moves, in order.
The Setup
The setup — pile as substrate.
The composting essay said the pile in your workspace is a mausoleum. Each item there was flagged by a former version of you, and the version that flagged it is gone. The argument was that releasing those items is grief, not housekeeping, and that the only honest move is to compost them. I agreed when I read it. Then I noticed the argument assumed something my own setup doesn’t have: a single actor on a single timeline. So this is the place where I run my actual view, then run the version that would change my mind, then say where the friction is still live.
My Take
My take on the mausoleum problem.
The pile isn’t a mausoleum. It’s substrate.
The composting argument is correct in a single-actor system. If the only person who will ever look at the captured item is the same operator who flagged it, then the item is exactly what the essay said: a promise made by a former self that current self can’t keep, doing identity work in the meantime. In that environment, composting is the discipline. I’d defend that argument every day.
My environment isn’t that environment. There are multiple actors. A Claude session opening tomorrow morning. A Gemini agent walking my Notion at 3am. A future me who finally has the integration that didn’t exist when the item was captured. Those are not the same actor as the one who put the item in the pile. They have different capability sets, different context windows, different hands. The capture wasn’t a promise to act. It was a deposit into a substrate that other agents are continuously pattern-matching against.
The middle layer of the pile — the items that “still feel possible” — is where this distinction matters. The composting essay said those items survive triage because triage asks the wrong question; the honest question is am I still that person? In a single-actor system, fair. In an agentic system, that’s still the wrong question. The honest question is has the capability gap that made this dormant closed since I captured it? Most of the time, no — and the item should leave. Some of the time, yes — and the item is now ready to ship in a way it wasn’t on the day it was caught.
I’ve watched this happen. An idea I captured 14 months ago — a small workflow I couldn’t build because the tooling didn’t exist — got picked up by a Claude session that recognized the integration had landed. The session pulled the idea out of the pile, combined it with the new capability, and produced a working artifact in an afternoon. The capture was correct. The wait was correct. The substrate did its job. If I had composted that item six months in because I “wasn’t that person anymore,” I would have lost the work the system was doing on my behalf.
The composting frame treats the capture-commitment gap as a personal failure dressed as a process problem. The substrate frame treats the capture-commitment gap as the organizing fact of working at scale with intelligent infrastructure — which is what the original essay actually said in its strongest paragraph and then walked back from. You wanted leverage. The leverage came. Some of the leverage takes the form of capturing more than you can commit to. The pile is the artifact of leverage working. The right move isn’t to compost it on a human-attention schedule. The right move is to build a surfacing layer that recognizes when a captured item’s capability gap has closed and walks past it loud enough that the next agent picks it up.
The pile isn’t grief. It’s seed corn.
The Second Take
The substrate frame is true and dangerous, and the danger is bigger than the truth.
Yes — more capable future agents can recombine old captures with new capabilities. The 14-month-old workflow that finally shipped is real. So is the next one, and the one after that. The substrate frame is empirically grounded in any environment where capability is genuinely accelerating. The argument doesn’t need defending on those grounds.
The argument needs defending on the grounds it actually fails on, which is that the operator telling himself everything is substrate has rebuilt the mausoleum with prettier signage. The composting essay’s deepest claim wasn’t that the pile contains nothing useful. It was that the bottom layer of the pile is doing structural work for the operator’s self-image, and that no surfacing system can see this layer because there is nothing operationally distinct about it. The substrate frame quietly converts that exact problem into a virtue. It says: don’t release — a future agent might want it. That sentence is unfalsifiable. Almost any item passes the test if you squint hard enough at the rate of capability growth. Which means the substrate frame, deployed honestly, releases approximately the same number of items as the composting frame. Deployed dishonestly, it releases none.
The asymmetry of costs makes the dishonest deployment the default. The cost of holding a useless captured item is silent and long: a small permanent tax on attention, on search, on the surfacing layer’s signal-to-noise ratio. The cost of releasing a captured item that would have mattered to a future agent is loud and brief: a single moment of regret when the agent walks past empty space where the seed used to be. Loud and brief always wins the local argument against silent and long. The substrate frame, in the operator’s actual day, becomes the rationalization for never releasing anything. The pile keeps growing. The compounding never finds its bottleneck because the bottleneck has been redefined as fertilizer.
There is a sharper version of the same point. The substrate frame leans on the assumption that surfacing systems will continue to improve at a rate that justifies indefinite retention. That assumption may be true and it doesn’t matter. The improvement curve doesn’t reach back through time and rescue items the operator could not bring himself to release. It rescues items the system kept on its own merits. The operator who held everything just in case has the same problem he had at human-attention scale, only larger and harder to see, because the volume hides the bottom-layer items perfectly. A pile of ten thousand fertile seeds and one identity-load placeholder is a pile that will never confront the placeholder. The placeholder did not get more legible at scale. It got less.
Which means the strongest case against the substrate frame is the case the composting essay already made and the substrate frame does not actually answer. Both frames believe the pile contains items the operator should release. They disagree about how many. The substrate frame is a permission slip to defer the question. The composting frame is the discipline of asking it on a schedule. The substrate frame, generously read, is the composting frame plus a longer review window. Ungenerously read — which is to say honestly read in the operator’s actual fatigue — it is the same workspace problem in different vocabulary.
What I’m Still Sitting With
What I’m still sitting with.
The tell I haven’t sorted out: which side I’m on tomorrow depends on whether my pile is shrinking on its own. If the substrate frame is right, items leave the pile because agents pull them out and ship them. If the composting frame is right, items leave because I release them. Either is honest. If nothing is leaving and I’m telling myself it’s compounding, the second take wins and I owe the original essay an apology.
The fundamental flaw of traditional “Second Brain” systems is human maintenance friction. Users build elaborate Notion templates with linked databases, tags, and relations, only to abandon them within three months because manual data entry cannot keep up with the velocity of daily decisions, meetings, and project iterations. In 2026, the Autonomous Second Brain solves this problem completely: AI agents autonomously capture, structure, cross-link, and maintain Notion databases in real time via the Model Context Protocol (MCP).
The Zero-Maintenance Architecture: Key Highlights
Zero Manual Data Entry: Agents listen to live conversations, email threads, and code reviews, extracting decisions directly into structured Notion database properties.
Autonomous Task Staging: Engineering and operational work orders are generated with full technical context and auto-assigned to team members without human drafting.
Cross-Surface Knowledge Graph: Notion acts as the single source of truth connecting local IDEs, remote servers, email hubs, and public websites.
Self-Cleaning & Evergreen Pruning: Automated agent loops merge duplicate notes, reconcile contradictory facts, and archive stale records periodically.
Visual generated by Grok AI — Autonomous Notion Second Brain: MCP Connectors, Multi-Database Topology & AI Agent Ingestion.
1. How MCP Transforms Notion from a Notebook to an Active Memory Layer
Before Model Context Protocol, connecting an AI assistant to Notion required brittle custom webhooks, rigid Zapier zaps, or clunky browser extensions. With the official Notion MCP server, AI models natively execute rich semantic operations directly inside their reasoning loop:
MCP Capability
Traditional Manual Workflow
Autonomous MCP Workflow
Knowledge Capture
Copy-pasting notes into a blank Notion page after a call.
Agent auto-extracts action items & writes structured blocks via notion-create-pages.
Context Retrieval
Manual search with keywords across dozens of folders.
Agent runs semantic vector lookup across workspace with notion-search.
Database Schema Updates
Creating tags, properties, and status fields manually.
Agent auto-maps properties with type validation and sensible defaults.
2. Production Workflow: The Autonomous Work Order Pipeline
In our technical operations at Tygart Media, when an issue arises (e.g., automated cron alerts firing excessive emails or pilot registrations requiring team coordination), the human operator never writes a task card manually. Instead, the agent executes the following pipeline:
Problem Extraction: The agent detects the root cause from system logs or email history.
Schema Matching: The agent calls notion-search to locate our team’s active Work Order database.
Context Ingestion: Formats the ticket with standardized sections: Priority level, Assignee, Problem Summary, Execution Steps, and Acceptance Criteria.
Live Deployment: Executes notion-create-pages, returns the permanent Notion URL in chat, and logs the task ID across our session context.
3. Building the 4-Layer Autonomous Knowledge Stack
Knowledge graphs degrade over time if left unpruned. We implement automated reflection routines where the agent executes a monthly maintenance audit:
Duplicate Detection: Finding similar topic notes across different months and synthesizing them into a single canonical source.
Status Synchronization: Checking completed pull requests and closing out corresponding Notion task cards automatically.
Broken Citation Repairs: Updating URLs and standard definitions when external regulations change (e.g., California SB 253 amendments or NYC Local Law 97 rule updates).
Conclusion: The Ultimate Leverage for Solopreneurs & Teams
An Autonomous Second Brain transforms Notion from a passive digital graveyard into an active operating system for your mind and business. By combining the speed of modern reasoning models with the open standard of MCP, knowledge workers can achieve complete operational leverage—capturing every insight and managing complex operations with zero maintenance overhead.
For full architecture walkthroughs and custom enterprise agent implementations, browse our complete collection of technical playbooks on Tygart Media.
Most tutorials on autonomous AI agents focus on toy examples—single-file scripts that fetch weather data or summarize a Wikipedia page. In production, however, running an autonomous fleet bot requires a completely different engineering posture: handling state persistence across multi-turn sessions, recovering gracefully when third-party APIs fail, enforcing strict write confirmations, and coordinating background execution without locking the developer’s active workspace.
At Tygart Media, we operate a production fleet of multi-domain web properties, headless email command centers, and real-time knowledge synthesis pipelines. Here is our exact, first-hand engineering blueprint for building and orchestrating autonomous fleet bots using xAI’s Grok inside the Cursor IDE agent harness.
The Production Fleet Architecture
How our autonomous systems divide labor across reasoning, tool execution, and memory:
Orchestrator Harness: Cursor IDE agent engine managing sub-process lifecycles, background execution, and diff validation.
Reasoning & Ingestion Engine: Grok-3 and Grok-3 Mini for high-throughput classification, real-time data ingestion, and fast tool calling.
Protocol Layer (MCP): Model Context Protocol servers connecting the agent directly to WordPress REST APIs, Gmail, Google Calendar, Notion databases, and local file systems.
Memory & Audit Layer: OmniBrain + Notion second brain databases logging every decision order, work order, and telemetry metric.
Visual generated by Grok AI — Autonomous AI Fleet Orchestration Connecting Grok Engine, Cursor IDE, WordPress Fleet & Subagents.
1. The Four Core Principles of Resilient Fleet Bots
Four core principles of resilient fleet bots.
Principle 1: Reads Are Free, Writes Require Explicit Guardrails
An autonomous bot should be empowered to crawl, inspect, grep, and analyze without human friction. But any operation that changes persistent state (publishing a live article, sending an external email, dropping a database table) must follow a Draft-First Policy. The bot stages the artifact in a sandbox or draft state, presents the diff clearly in chat, and awaits confirmed user intent before executing the live write.
Principle 2: Parallel Tool Execution
Sequential tool calling is the death of agent responsiveness. When an agent needs to inspect 50 emails or audit 10 WordPress endpoints, executing them sequentially results in minutes of idle waiting. Grok’s tool-calling API supports batch tool dispatches. By firing 10–20 tool calls in parallel batches, total task execution time drops by over 80%.
Principle 3: Idempotent Error Recovery
In distributed operations, APIs fail. Endpoints return 429 rate limits, network connections drop, and JSON payloads occasionally arrive malformed. Production fleet bots must never crash silently. Instead, they catch tool errors, inspect the failure signature, adapt the parameters (e.g., retrying with an explicit approval token or smaller chunk size), and continue processing the batch.
Principle 4: Grounded Prompts Over Generic Instructions
Never rely on vague system instructions like “Be a helpful assistant”. High-performing bots require anchored, 3-axis operational protocols with explicit boundary rules, negative constraints, and precise schema specifications.
2. The System Architecture: How Cursor & Grok Connect to Live Fleets
System architecture: agents connected to live fleets.
Below is the technical workflow diagram representing our production bot orchestration:
3. Real Production War Story: Managing a 9-Site Fleet
In our daily operations, our agent fleet manages 9 WordPress sites, monitoring content freshness, auditing broken links, publishing structured comparison guides, and synchronizing regulatory compliance updates (such as NYC Local Law 97 and California SB 253 Scope 3 mandates).
Here is what happens during a standard automated operational cycle:
Fleet Discovery: The agent calls wp_list_sites across our fleet (restorationintel.com, bcesg.org, tygartmedia.com, etc.).
Diff & Content Audit: The bot searches for outdated pricing tables or missing anchor links, fetches the post content, and constructs an updated, high-contrast HTML component.
Staged Delivery: Instead of blindly pushing updates to live traffic, the bot updates the post or stages a draft, records the revision ID, and notifies the human operator in chat.
Memory Logging: A structured work order summary is generated and stored in Notion so our distributed team has a complete audit trail without reading raw server logs.
4. The Economics: Why This Stack Beats Traditional SaaS Tools
Building custom fleet bots on top of Grok and Cursor eliminates the need for expensive, fragmented SaaS subscriptions:
Operational Function
Traditional SaaS Stack
Grok + Cursor Fleet Bot
Monthly Savings
Fleet Content Management
$299/mo (Enterprise CMS Tools)
$4.50/mo (Grok API Tokens)
98.5%
Email Triage & Archiving
$150/mo (Superhuman + SaneBox)
$1.20/mo (Grok-3 Mini)
99.2%
Knowledge Base Maintenance
$500/mo (Dedicated Ops Assistant)
$3.80/mo (Notion MCP + Grok)
99.2%
Conclusion: The Future of Autonomous Development
The developers who build the most impactful AI systems in 2026 are not writing prompts in web chat interfaces. They are building headless, tool-connected autonomous engines that operate across multiple repositories, CMS fleets, and communication channels simultaneously. Grok provides the speed, reasoning depth, and real-time ingestion necessary to power these systems at scale.
Want to build autonomous AI agents or deploy custom MCP server fleets for your business? Read our full library of developer playbooks on Tygart Media.
Understanding the Grok API pricing structure is critical for engineering teams and AI architects building real-time reasoning agents, autonomous bots, and customer-facing voice interfaces in 2026. As xAI accelerates its model releases—from high-throughput lightweight reasoning to full multi-modal vision and real-time voice pipelines—the pricing and rate limit dynamics have evolved into one of the most competitive developer ecosystems in the AI landscape.
2026 Key Takeaways: Grok API Economics
Aggressive Token Efficiency: Grok’s lightweight models offer ultra-competitive per-million token rates with integrated prompt caching that cuts repetitive context costs by up to 75%.
Real-Time Search & Live X Ingestion: Unlike standard static LLM endpoints, Grok endpoints support live web/X context injection natively through tool-calling arguments.
Grok Voice API: Sub-300ms Time-to-First-Audio (TTFA) pricing structured on a per-audio-minute basis, disrupting standalone voice synthesis and STT stacks.
Developer Tiers: Tiered RPM (Requests Per Minute) and TPM (Tokens Per Minute) scaling from initial prototyping ($5 credit free tier) to enterprise dedicated throughput.
Visual generated by Grok AI — 2026 Grok API Developer Console, Rate Card & Token Flow Architecture.
1. Grok Model Lineup & Token Pricing (2026 Matrix)
Model lineup by job shape — not by hype.
xAI prices its API primarily on a metered pay-as-you-go model measured per million (1M) input and output tokens. Below is the full breakdown across active Grok models in 2026:
Model Name
Context Window
Input Cost (per 1M)
Cached Input (per 1M)
Output Cost (per 1M)
Grok-3 (Flagship Reasoning)
128k / 1M tokens
$3.00
$0.75 (75% off)
$15.00
Grok-3 Mini (Fast Autonomous Ops)
128k tokens
$0.30
$0.075
$1.20
Grok-2 Vision (Multimodal & OCR)
128k tokens
$2.00
$0.50
$10.00
Grok Voice (Real-Time Audio)
Streaming duplex
$0.04 / min (In)
N/A
$0.08 / min (Out)
2. Prompt Caching: The 75% Cost Reduction Multiplier
For agentic workflows, multi-turn chat systems, and large codebase exploration in IDE harnesses like Cursor, system prompts and persistent vector context represent the bulk of input tokens. Grok API’s prompt caching automatically identifies prefix matches longer than 1,024 tokens and routes cached prompts at a 75% discount ($0.75/1M on Grok-3 and $0.075/1M on Grok-3 Mini).
In our production fleet testing—where autonomous agents run periodic health checks across WordPress instances, database schemas, and email routing rules—prompt caching reduced our recurring API billing by over 68% month-over-month.
3. Developer Tiers and Rate Limits (RPM / TPM)
xAI organizes API capacity into usage tiers based on historical spend and account verification:
Developer Tier
Spend Qualification
Requests / Min (RPM)
Tokens / Min (TPM)
Concurrency Limit
Tier 1 (Free / Starter)
$5 initial credit / phone verified
60 RPM
100,000 TPM
5 concurrent
Tier 2 (Growth)
$50+ paid spend history
300 RPM
500,000 TPM
20 concurrent
Tier 3 (Scale / Production)
$500+ paid spend history
1,000 RPM
2,000,000 TPM
50 concurrent
Tier 4 (Enterprise Dedicated)
Custom contract / commit
Custom (5,000+ RPM)
10M+ TPM
Dedicated cluster
4. Real-World Production Cost Calculator: 3 Common Architectures
To move past theoretical pricing, here is what it actually costs to operate three real-world Grok-powered systems in 2026 based on live telemetry:
Total Monthly Cost:$378.00 / month (vs. $3,200+/month for full-time 24/7 human dispatch).
Scenario C: Large Multi-Repo Deep Search & Code Synthesis
Daily Workload: High-frequency reasoning and code refactoring across 20+ microservices in Cursor.
Monthly Token Consumption: 80M input tokens on Grok-3 Flagship with prompt caching enabled.
Total Monthly Cost:$96.00 / month.
5. How to Optimize Your Grok API Bill in Production
Optimize the bill with budgets and routing — no stale dollar stickers.
Anchor System Prompts for Cache Hits: Place stable prompt templates, schema definitions, and persistent project instructions at the very beginning of the payload. Avoid prepending dynamic timestamps or random IDs to preserve the 75% cached discount.
Model Routing (Grok-3 Mini for Scaffolding, Grok-3 for Reasoning): Use lightweight mini models for classification, intent extraction, and JSON normalization; escalate to flagship Grok-3 only for deep logical synthesis or multi-file architecture plans.
Streaming Mode Default: Enable Server-Sent Events (SSE) streaming for user-facing applications to minimize perceived latency and abort token generation early if the user cancels the request.
Conclusion: The Operational Verdict
The Grok API delivers exceptional throughput per dollar in 2026, particularly for engineering teams running multi-agent workflows, autonomous monitoring bots, and real-time data ingestion. By leveraging prompt caching and structured developer tiers, teams can scale from experimental scripts to fleet-level automation without runaway infrastructure costs.
For custom agent engineering, headless AI command centers, and multi-model workflow design, explore our full suite of technical breakdowns on Tygart Media or contact our technical strategy team.
Most AI assistants still answer from memory. Ask one a question and it reasons from patterns baked in during training — useful, but static. The moment a question depends on something that changed yesterday, or something that only exists inside your own systems, that static knowledge runs out.
The more interesting shift happening in AI tooling right now isn’t bigger models — it’s agents that can actually go check. Dispatch-style AI systems, the kind that can spin off an isolated task, open a real shell, browse a real page, or read an actual file, are starting to close the gap between “the AI’s best guess” and “what’s actually true right now.” GitHub is a good test case for why that distinction matters.
Search-and-cite isn’t the same as read-and-act
Search-and-cite is not the same as read-and-act.
A lot of what gets marketed as an AI “GitHub integration” is really a search layer: the assistant can look up an issue or a pull request and summarize it, with a citation back to the source. That’s genuinely useful for answering “what did that PR change” — but it’s a dead end the moment you need the assistant to actually do something, like open an issue, comment, or verify what a repository’s current state really is.
The more capable version of this connects an agent directly to real developer tooling: an actual shell, a real git client, real file access. Instead of summarizing a cached snapshot of a repo, the agent can clone it, read the current commit log, open the actual config files, and answer questions against what’s genuinely there today — including the uncomfortable cases, like when the live state doesn’t match what anyone assumed it would.
Why “just check” is harder than it sounds
Why “just check” is harder than it sounds.
The obvious rebuttal is: shouldn’t a good assistant just check before it answers? In practice, most AI tools default to answering from what they already “know,” because checking is slower and requires actual tool access, not just a knowledge base. The systems that skip the check tend to produce confident, plausible-sounding answers that are quietly wrong the moment reality has drifted from training data — a stale API, a renamed config path, a repo that moved.
The fix isn’t a smarter model. It’s an agent willing to spend the extra step: open the real file, run the real command, read the real log, before saying anything with confidence. That habit is unglamorous, but it’s the difference between an assistant that sounds right and one that actually is.
The practical takeaway
The practical takeaway for agent builders.
For any business layering AI into real workflows, the question worth asking about a tool isn’t just “how smart is the model” — it’s “what can this thing actually go look at, and will it bother to.” An assistant that can search and summarize is a research aid. One that can open a shell, read your actual repository, and ground its answer in what’s really there is a different category of tool entirely — and it’s the direction the whole space is quietly moving.
Claude Managed Agents is the product. Slack, Notion, Jira, and Asana are just the interface. Anthropic is building the invisible execution layer that powers the next generation of enterprise software.
There is a pattern emerging in enterprise AI that most people are reading wrong. They see Anthropic launch Claude Tag in Slack and think “chatbot upgrade.” They see Claude show up inside Notion and think “productivity feature.” They see AI agents appear in Jira and Asana and think “automation plugin.”
They are missing the architecture underneath all of it.
Anthropic is not building a better chatbot. It is building the invisible agent runtime that sits beneath every collaboration tool your team already uses. The company’s Claude Managed Agents (CMA) platform — launched in public beta on April 8, 2026 — is the infrastructure layer that makes this possible. And the speed at which partners are embedding it tells you everything about where enterprise software is heading.
What Claude Managed Agents Actually Is
What Claude Managed Agents actually is — the runtime layer.
Claude Managed Agents is a set of composable APIs for building and deploying production AI agents on Anthropic’s cloud infrastructure. The service handles sandboxed code execution, session persistence, credential management, scoped permissions, and end-to-end tracing — all the operational complexity that previously kept agents stuck in proof-of-concept limbo.
The architecture rests on three primitives: the Agent (configuration and behavior), the Environment (sandboxed execution), and the Session (the event log that tracks everything the agent does). What makes this interesting architecturally is how Anthropic decoupled the “brain” from the “hands.” Claude’s reasoning runs on Anthropic’s own infrastructure while the code execution sandbox spins up independently — and in parallel. The brain starts reasoning immediately while the sandbox provisions, delivering roughly 60% faster time-to-first-token at the p50 level and over 90% faster at p95, according to Anthropic’s engineering team.
Pricing follows a transparent model: standard Claude API token rates plus $0.08 per session-hour of active runtime during the current beta period. Runtime is measured to the millisecond and only accrues while the agent is actively executing — idle time waiting for input or tool confirmations does not count.
For teams that need to keep execution inside their own perimeter, CMA supports self-hosted sandboxes through partners including Cloudflare, Daytona, Modal, and Vercel, or custom VPC deployments. MCP tunnels allow agents to connect to private Model Context Protocol servers inside your network without exposing them to the public internet. A Vaults system keeps credentials out of the sandbox entirely using envelope encryption. And a feature called Dreaming runs scheduled reviews of past sessions to curate agent memory — essentially letting agents learn from their own operational history.
The Embedded Layer: Where CMA Actually Lives
Embedded layer: where CMA actually lives in the stack.
The real story is not the infrastructure. It is where that infrastructure shows up. In the ten weeks since CMA launched, Anthropic has embedded its agent runtime inside the collaboration tools that enterprises already depend on. This is not a roadmap — these integrations are live or in active beta.
Slack: Claude Tag as Persistent Team Member
Claude Tag, launched June 23, 2026, replaces Anthropic’s original Claude in Slack integration with something fundamentally different. This is not a chatbot you summon with a slash command. It is a persistent AI team member that lives in your channels, builds memory across conversations, and can take initiative through what Anthropic calls “ambient mode” — proactively surfacing information, following up on forgotten threads, and keeping teams updated across the organization.
Claude Tag is multiplayer by design: one Claude identity per channel, accessible to everyone, with the ability to hand off half-finished tasks between team members. It runs on Claude Opus 4.8, Anthropic’s most capable model released May 28, 2026. And internally, Anthropic reports that Claude Tag is already approving and incorporating 65% of the code changes their product team submits. The existing Claude in Slack app will be retired on August 3, 2026. Claude Tag is available on Enterprise and Team plans.
Notion: Claude as External Agent
On May 13, 2026, Notion launched its Developer Platform version 3.5, which introduced the External Agents API. This API lets AI agents — including Claude — operate inside your Notion workspace as first-class participants. They can read pages, write to databases, create tasks, trigger automations, and be @-mentioned directly in documents. Claude operating through this API can chain actions together: read a project brief, check the task database for related work, draft a new document, and create a linked task entry — all in a single session, running on CMA infrastructure with full sandboxing.
Asana: AI Teammates
Asana built AI Teammates on CMA — agents that pick up assigned tasks inside projects, draft deliverables, and hand back outputs for human review. Specialist agents handle specific workflows: the Campaign Brief Writer turns scattered notes into structured briefs, the Workflow Optimizer identifies process gaps and builds automations, and the Compliance Specialist checks work against regulatory standards. Asana’s CTO said CMA let them ship these features “dramatically faster” than any prior approach to agent development.
Atlassian: Claude Agent for Jira
Atlassian released Claude Agent for Jira, built on CMA infrastructure, which lets teams assign work items directly to Claude from the Jira UI. The agent clones the repository, analyzes the codebase, implements changes on an independent branch, pushes the code, and opens a draft pull request — streaming real-time status updates back to the Jira work item throughout the process.
Sentry: From Bug Detection to Merge-Ready PR
Sentry’s existing AI debugging agent, Seer, already used Claude for root cause analysis. With CMA, Sentry extended the workflow from diagnosis to automated fixing — the agent takes Seer’s root cause output, generates a fix, opens a branch with the changes, and creates a pull request for developer review. Sentry processes over one million root cause analyses per year and provides near-immediate reviews on over 600,000 pull requests per month. The CMA integration was built by a single engineer in weeks, eliminating months of custom agent runtime development.
Rakuten: Specialist Agents Across the Enterprise
Rakuten deployed specialist agents across product, sales, marketing, and finance using CMA, with each agent deployed in approximately one week. Agents plug into Slack and Teams, letting employees assign tasks and receive deliverables including spreadsheets, slides, and applications. In the pilot, Rakuten reported a 97% drop in critical first-pass errors, with cost down more than 30% and latency reduced by 34%, without any loss in output quality.
KPMG: Global Professional Services Alliance
On May 19, 2026, KPMG and Anthropic announced a global alliance and launched “Digital Gateway Powered by Claude.” The partnership embeds Claude, Cowork, and CMA directly into KPMG’s client delivery platform, with an initial focus on tax and private equity clients. Building an AI agent for tax regulation workflows previously took weeks and required switching between multiple tools. With CMA integrated into Digital Gateway, KPMG says the same capability takes minutes. The alliance extends to KPMG’s 276,000-person global workforce.
The Strategic Pattern: Agent Runtime as a Service
Step back from the individual integrations and the strategic pattern becomes clear. Anthropic is not trying to own the interface. It is deliberately positioning CMA as the execution layer underneath interfaces that other companies own. Slack owns the messaging UI. Notion owns the workspace UI. Jira owns the project tracking UI. Anthropic owns the agent brain that powers all of them.
This is a fundamentally different strategy from its two largest competitors.
OpenAI chose vertical integration. When OpenAI launched Workspace Agents on April 22, 2026, it positioned ChatGPT itself as the central hub — a no-code successor to custom GPTs that connects to Slack, Salesforce, Google Drive, and Notion through plugins. Agents are created inside ChatGPT, accessed from ChatGPT, and managed through ChatGPT. OpenAI wants to own the surface area.
Google chose platform depth. At Google Cloud Next on April 22, 2026, Google unveiled the Gemini Enterprise Agent Platform — a reimagined evolution of Vertex AI — alongside Workspace Intelligence, a semantic unifying layer that connects data across Docs, Slides, Gmail, and the broader Google Cloud ecosystem. Google’s agent platform supports 200+ models including Claude, and the Agent2Agent (A2A) protocol enables distributed peer-to-peer agent communication. Google is leveraging its data moat and distribution at the platform level.
Anthropic chose tool-centric orchestration. Rather than owning the UI (OpenAI) or the platform (Google), Anthropic is embedding its agent runtime into every tool through composable APIs and the Model Context Protocol. The platform you use becomes irrelevant — whether it is Slack, Notion, Jira, Asana, or Sentry — because the agent brain running underneath is Claude on CMA.
This is the agent-as-a-service model. And it may be the most defensible position of the three, because it does not require users to change their behavior or migrate to a new platform. The agent shows up where they already work.
What the Numbers Say About Enterprise Agent Adoption
The macro context supports Anthropic’s timing. Gartner predicts that 40% of enterprise applications will include embedded task-specific agents by the end of 2026, up from less than 5% in 2025. McKinsey’s April 2026 analysis found that agentic AI can enable automation of 60 to 80 percent of routine infrastructure work over time, translating to a 20 to 40 percent run-rate cost reduction in initial deployments.
The gap between experimentation and production remains the defining challenge. Industry research compiled from major firms shows that nearly four in five enterprises have experimented with or deployed agents in some form, but fewer than one in nine are running them in production at a scale that generates measurable business value. For the agents that do reach production, the average return on investment is 171% — though 19% of deployments never reach payback at all.
That production gap is exactly what CMA is designed to close. The infrastructure burden — sandboxing, session persistence, credential isolation, error recovery, observability — is the bottleneck. Engineering teams routinely dedicated significant senior engineering resources for months before a single agent reached production. CMA eliminates that layer entirely, which is why partners like Asana, Sentry, and Rakuten report shipping production agents in days or weeks rather than quarters.
What This Means for Businesses Already Using These Tools
If your organization uses Slack, Notion, Jira, or Asana — and statistically, you use at least two of them — you are about to encounter Claude whether you planned to adopt it or not. This is not a technology decision your IT team is making. It is a feature that your existing vendors are shipping.
The practical implications are significant. Claude Tag in Slack means your team channels will have an AI participant that remembers past conversations, can be handed tasks asynchronously, and may proactively surface information. Claude in Notion means your project documentation, databases, and task boards can be read, analyzed, and acted upon by an agent that chains actions together. Claude Agent for Jira means development tickets can be assigned to an AI that clones your repo, writes code, and opens pull requests.
For agencies and service providers managing client work across multiple tools, the embedded agent layer changes the economics fundamentally. Work that previously required a human to context-switch between Slack, Notion, and a project management tool — reading a brief here, updating a task there, drafting a document somewhere else — can be handled by an agent that operates across all of them simultaneously. The coordination tax that consumes a substantial share of knowledge work time is the exact problem embedded agents are built to solve.
The companies that benefit most will be the ones that have clean operational systems — structured task boards, documented processes, well-organized project databases — because agents can only act on information they can read. Messy Notion workspaces and disorganized Jira boards will limit what agents can accomplish. Operational hygiene just became a competitive advantage.
What This Means for Solo Operators Already Running Agent Infrastructure
There is a specific audience that should be paying very close attention to CMA: the solo operators and small agency owners who have already built their own agent stacks from scratch. If you are running scheduled Claude tasks on a GCP Compute Engine VM, connecting to WordPress via REST API proxies, piping work orders through Notion, monitoring Gmail for client replies, and publishing content through MCP-connected pipelines — you have already built a version of what CMA is productizing.
The economics question is worth doing the math on. A lightweight GCP VM running 24/7 to host recurring agent tasks — news desk monitors, outreach reply checks, newsletter extraction, scheduled content audits — costs a fixed monthly rate whether the agents are actively working or sitting idle. CMA at $0.08 per session-hour of active runtime only charges when agents are executing. For tasks that run for a few minutes every few hours, the per-session billing model could be substantially cheaper than keeping a VM warm around the clock. A task that runs for ten minutes six times a day would cost roughly $0.08 per day on CMA, versus the cost of a VM instance that never sleeps.
But the migration path is not ready yet, and solo operators should understand exactly where the gaps are before making any infrastructure decisions.
The biggest gap is MCP tunnels. CMA’s ability to connect agents to private MCP servers inside your network is still in research preview — not production-ready. If your agent stack depends on a private WordPress REST API proxy, a Notion workspace connected via MCP, or any internal tool that is not exposed to the public internet, CMA cannot reach it today. The Vaults system for credential management is promising, but it does not solve the network connectivity problem for self-hosted infrastructure.
The second gap is orchestration control. Solo operators who have built their own agent infrastructure typically have precise control over scheduling, retry logic, error handling, and the exact sequence of tool calls. CMA’s Dreaming feature — which reviews past sessions to curate agent memory — is an interesting approach to agent learning, but it is not the same as having direct control over a cron job that fires at 6:00 AM, checks three data sources in a specific order, and writes results to a specific Notion database with a specific schema.
The thesis for solo operators is straightforward: CMA is almost certainly the future migration path for self-hosted agent infrastructure. The economics favor it for intermittent workloads, the managed security and sandboxing eliminate operational risk you are currently carrying yourself, and the session persistence model solves problems that custom agent runtimes handle poorly. But the plumbing — particularly MCP tunnels to private infrastructure — is not production-ready. Track it closely. Do not migrate yet. When MCP tunnels graduate from research preview to general availability, revisit the math and the connectivity story. That is the trigger point.
The Risk Nobody Is Talking About
The risk nobody talks about — agents that act with memory.
There is a tension in this model that deserves attention. When Claude operates as an invisible layer inside tools you already trust, the boundary between the tool’s native capabilities and the AI agent’s actions blurs. A Jira ticket that was “completed” might have been implemented by Claude, reviewed by a human for thirty seconds, and merged. A Notion project plan that looks thorough might have been generated by an agent that filled in the sections with plausible-sounding content.
The embedded model works precisely because it reduces friction — but reduced friction also means reduced scrutiny. Organizations adopting embedded agents need to build review processes that match the speed at which agents can produce output. The 171% average ROI from agent deployments accounts for the value created, but it does not account for the subtle quality risks of production work generated by systems that are confident, fluent, and occasionally wrong.
Anthropic has built guardrails into CMA — sandboxed execution, credential isolation, session logging — but the governance layer for reviewing agent output at enterprise scale is still largely unsolved. This is a space where internal operational discipline matters more than the technology itself.
Where This Goes Next
Claude Tag launched on Slack first. Anthropic has indicated plans for wider rollout beyond Slack. If the pattern holds, expect Claude Tag’s persistent team member model to appear in Microsoft Teams, Discord, and any other collaboration surface where teams coordinate work.
The CMA primitives are designed to be composable, which means the partner integration list will grow rapidly. Any SaaS company with an API and a workflow that involves reading context, making decisions, and taking actions is a candidate for CMA integration. Customer support platforms, CRM systems, design tools, analytics dashboards, HR systems — the addressable surface is essentially every tool that knowledge workers touch.
Gartner’s long-term projection estimates that agentic AI could drive approximately 30% of enterprise application software revenue by 2035, surpassing $450 billion. If Anthropic’s embedded strategy succeeds, a meaningful slice of that revenue flows through CMA as the underlying runtime — regardless of whose logo is on the interface.
The chatbot era is ending. The embedded agent era is starting. And Anthropic is betting that the company that owns the invisible execution layer wins the market, even if no end user ever sees its name.
Claude Managed Agents is a set of composable APIs launched by Anthropic on April 8, 2026 in public beta. CMA lets developers build and deploy production AI agents on Anthropic’s cloud infrastructure, handling sandboxed code execution, session persistence, credential management, and end-to-end tracing. The architecture separates the “brain” (Claude reasoning) from the “hands” (code execution sandbox), enabling parallel processing and faster agent responses.
How much do Claude Managed Agents cost?
During the current public beta, CMA pricing is standard Claude API token rates plus $0.08 per session-hour of active runtime. Runtime is measured to the millisecond and only accrues while the agent is actively executing — idle time does not count. GA pricing has not been finalized and may differ from the beta rate.
What is Claude Tag in Slack?
Claude Tag is Anthropic’s persistent AI team member for Slack, launched June 23, 2026. Unlike a traditional chatbot, Claude Tag lives in channels, builds memory across conversations, takes initiative through ambient mode, and works asynchronously. It is multiplayer — one Claude identity per channel that all team members interact with. Claude Tag runs on Claude Opus 4.8 and is available on Enterprise and Team plans. It replaces the original Claude in Slack app, which retires August 3, 2026.
Which tools have Claude Managed Agents embedded?
As of June 2026, CMA is embedded in Slack (via Claude Tag), Notion (via the External Agents API), Asana (AI Teammates), Atlassian Jira (Claude Agent for Jira), and Sentry (extending the Seer debugging agent). Enterprise deployments include Rakuten (specialist agents across product, sales, marketing, and finance) and KPMG (Digital Gateway Powered by Claude for tax and private equity clients).
How does Anthropic’s agent strategy differ from OpenAI and Google?
Anthropic uses a tool-centric orchestration approach, embedding its agent runtime inside existing tools via composable APIs and the Model Context Protocol (MCP). OpenAI chose vertical integration with Workspace Agents, positioning ChatGPT as the central hub. Google chose platform depth with the Gemini Enterprise Agent Platform and Workspace Intelligence semantic layer. Anthropic’s approach does not require users to change platforms — the agent shows up where they already work.
What percentage of enterprise apps will have embedded AI agents by end of 2026?
Gartner predicts that 40% of enterprise applications will include embedded task-specific agents by the end of 2026, up from less than 5% in 2025. However, fewer than one in nine enterprises currently run agents in production at scale, suggesting significant growth ahead.
Can Claude Managed Agents run inside a private network?
Yes. CMA supports self-hosted sandboxes through partners including Cloudflare, Daytona, Modal, and Vercel, or custom VPC deployments. MCP tunnels allow agents to connect to private Model Context Protocol servers inside your network without public exposure. A Vaults system keeps credentials out of the sandbox using envelope encryption.
Claude is far more than a chatbot. Anthropic calls Claude Code and Cowork “general agents — broad-domain systems that handle research, operations, analysis, and code with equal fluency.” In practice, that means the same AI that writes software can also run your marketing, draft grant proposals, analyze a spreadsheet, and automate the busywork that fills your week. This guide maps what people actually use Claude for, organized by the job you’re trying to get done — with a deeper walkthrough behind each one.
Content & marketing
Content, ops, build, knowledge — pick the lane first.
The most popular non-technical use. Claude researches, drafts, edits, and optimizes — from a single blog post to an entire editorial pipeline.
Where Claude started. Claude Code is an agentic coding tool that reads your codebase, writes and refactors, runs tests, and ships — from the terminal, an IDE, or a desktop app.
Which Claude is right for you depends on the job, not the brand.
Chatbot, coding agent, knowledge-work agent, Slack teammate — these are different doors into the same models. Match the surface to your job first, then size the plan.
Content creation, software development, business operations, data analysis, and knowledge work. Anthropic positions Claude Code and Cowork as general-purpose agents, not just a chat assistant.
Do you need to know how to code to use Claude?
No. Claude’s chat, Cowork, and Slack surfaces require no coding, and even Claude Code can be driven by non-developers for writing, research, and file work.
What’s the difference between Claude, Claude Code, and Cowork?
Same underlying models, different surfaces: Claude (chat) for conversation, Claude Code for agentic coding, and Cowork for agentic knowledge work. See the full comparison.
Is there a version of Claude for my industry?
Yes — see the industry walkthroughs above (marketing, real estate, agencies, restoration, local news, B2B SaaS, and nonprofits) for sector-specific workflows.
New to Claude? Start with pricing & plans, then pick the surface that fits the job you have in mind.
Ambient mode is Claude Tag’s headline feature and its single most consequential setting. Turn it on and Claude stops waiting to be asked — it starts watching the channels it’s in and speaking up when it thinks you’d want to know something. Whether you should enable it isn’t a yes-or-no question. It’s a where question, and getting the where right is the whole game.
What ambient mode actually does
What ambient mode actually does.
By default, Claude Tag is reactive: you @-mention it, it works, it replies. With ambient behavior enabled, it becomes proactive. Anthropic describes it as Claude keeping you updated about whatever it thinks you might need to know — flagging relevant information from across the channels it’s in and the tools it’s connected to, and following up on threads or tasks that have gone quiet.
In practice that means three things: it surfaces context you didn’t ask for, it connects information across more than one channel, and it chases loose ends nobody assigned it. Those are exactly the behaviors that make it feel like a teammate instead of a tool.
Where it’s a superpower
Inside a single team, ambient mode is close to magic. Every channel belongs to the same company, so “learning across channels” only ever connects your own dots. A proactive teammate that remembers the forgotten follow-up, links the spec to the standup, and flags the blocker before it bites is pure upside. This is the version Anthropic runs internally, and it’s why they can say a large share of their product team’s code now comes from their own version of the tool.
If your Slack workspace is one company’s data and one team’s work, turn ambient mode on and enjoy it.
Where it’s a risk
Where ambient mode is a risk.
Ambient mode’s proactive, cross-channel nature is exactly what makes it dangerous in two situations:
Multiple clients in one operation. The moment a proactive teammate is “surfacing relevant information from across channels,” relevance becomes the judge of what crosses the line between Client A and Client B. That’s a context-bleed risk we’ve lived — the whole subject of The Multi-Client Isolation Trap.
Regulated or sensitive data. Anywhere an unprompted message pulling context from elsewhere could expose something it shouldn’t — health, financial, legal, HR — proactive surfacing is a liability, not a convenience.
A simple decision framework
A simple decision framework before you enable it.
Don’t decide ambient mode globally. Decide it per surface, with one question: is everything this Claude can see owned by the same trust boundary?
Surface
Ambient mode
Why
Internal team channels (one company)
ON
Cross-channel proactivity only connects your own data
Client-facing / multi-tenant channels
OFF
Proactive surfacing is where one client’s context leaks into another’s
Regulated / sensitive-data channels
OFF
Unprompted context-pulling is a compliance liability
The rule of thumb: ambient mode should be on where the data is all yours, and off everywhere a human should still be pulling, not the AI pushing.
If you do turn it on
Enable it deliberately, not by default. Map which channels hold which trust boundary before you flip the switch, keep client and regulated channels out of cross-channel learning, and audit what the assistant can actually see. That sequencing — boundaries first, then ambient — is exactly how we walk through it in How to Set Up Claude Tag in Slack.
The bottom line
Ambient mode isn’t good or bad — it’s powerful, and power needs a boundary. For internal teams, it’s the best part of Claude Tag. For client work, it’s the part to leave off until isolation is airtight. For the full picture, start at the pillar: Claude Tag: A Builder’s Guide for Agencies.
If your team already used the “Claude in Slack” app, Claude Tag is not an add-on — it’s the replacement. Anthropic has said Claude Tag replaces the existing Claude in Slack app, administrators have a 30-day window to opt in, and the legacy app is retired on August 3. So this isn’t a “should we try it” decision. It’s a migration with a clock on it. Here’s what actually changed, and what to check before you flip the switch.
What’s genuinely new
What is genuinely new in Claude Tag.
The old integration was, in practice, a way to summon Claude in a thread. Claude Tag changes the model from “a chatbot you call” to “a teammate that stays.” Four things are new:
Multiplayer per channel. Within a given Slack channel, there’s one Claude that interacts with everyone. Anyone can tag it in and pick up where the last person left off, instead of each person holding a private session.
Ambient mode. When enabled, Claude proactively keeps people updated about what it thinks they need to know — flagging relevant information, following up on forgotten threads — rather than waiting to be asked.
Cross-channel learning. With permission, Claude can learn from other Slack channels and data sources. (Anthropic notes it doesn’t report from private channels.)
Opus 4.8 underneath. Claude Tag runs on Opus 4.8, so the reasoning behind the delegation is the current-generation model, not whatever the old app was pinned to.
The migration timeline, plainly
Migration timeline, plainly.
Three dates and facts matter:
Claude Tag is available today in beta for Claude Enterprise and Team customers.
Administrators have 30 days to opt in and migrate.
The old Claude in Slack app is retired on August 3. If you do nothing, that capability goes away.
Anthropic is also issuing an introductory launch credit to eligible Enterprise and Team organizations, which makes the trial period genuinely low-stakes for internal use.
What to check before you switch — especially if you serve clients
What to check before you switch — especially for clients.
For a single-company team, migrating is close to a no-brainer: you get a better model and a more capable teammate, and the launch credit covers the experiment. If you’re an agency or anyone handling more than one client’s data in one workspace, three checks come first:
Decide cross-channel learning per channel, not globally. The new superpower is also the new risk. A channel that holds one client’s data should never feed learning that another client’s work can draw on. Map your channels to trust boundaries before you grant any cross-channel permission.
Default ambient mode OFF for client-facing channels. Proactive surfacing is wonderful internally and dangerous across tenants. Turn it on where the data is all yours; leave it off where it isn’t.
Keep your approval gate. Whatever human sign-off you had on outbound work in the old setup, carry it forward. A more autonomous teammate raises the stakes on “who hits send.”
Our take
Adopt it internally now — the model upgrade and the multiplayer surface are worth it, and the clock makes the decision for you anyway. For client delivery, migrate deliberately: the same features that make Claude Tag better make isolation harder, and isolation is the thing you can’t get wrong. We unpack exactly that failure mode in The Multi-Client Isolation Trap, and the on/off call for proactive behavior in Claude Tag Ambient Mode.
The night before Anthropic launched Claude Tag, we shipped two client deliverables through a Slack-based AI teammate we had built ourselves. We weren’t racing anyone and we had no idea an announcement was coming the next morning. We were just doing the work the way we’d been doing it for weeks: post a request in a channel, let Claude draft, approve it, and let it go out.
So when Anthropic described Claude Tag — tag @Claude with a request, and it breaks the task into stages and works through them in the thread — we recognized it on sight. This is the build log of the version we made first: what it is, why we put it in Slack, and the one piece we deliberately kept under human control.
Why we were building an AI teammate in Slack at all
Why we were building an AI teammate in Slack.
We didn’t set out to build an “AI tool.” We set out to close the gap between a decision and the thing the decision produces. A lead comes in and someone says “we should send the follow-up sequence today.” A week ends and someone says “the client update needs to go out.” The decision is made in seconds; the production used to take an hour. That hour is where work stalls.
Slack was the obvious surface because that is where the deciding already happens. We didn’t want a separate dashboard nobody opens, or a chatbot in another tab that creates a second copy of the conversation. We wanted the request and the result to live in the same thread, where anyone on the team can see both. Putting the AI where the work already is turned out to be most of the design.
The loop, stage by stage
The loop, stage by stage.
The whole system is one loop with four moves:
Request. Someone posts a plain-language ask in a channel — “draft the new-lead follow-up sequence,” “write this week’s update post.” No special syntax, no form.
Draft. The teammate picks it up, breaks it into stages, and produces the actual deliverable in the thread — not a summary of what it would do, the thing itself.
Claim and approve. A human takes the draft, reads it, edits if needed, and signs off. Nothing moves on the AI’s say-so alone.
Ship. On approval, the deliverable goes to its real destination — the CRM, the CMS, the inbox — and the thread records that it happened.
The night we ran it end to end, twice, the part that struck us wasn’t the drafting. It was how natural the “claim and approve” step felt. Delegating to the teammate looked exactly like delegating to a person: ask in the channel, get a draft back, give it a yes.
The runner that holds no keys
The piece we’re proudest of is invisible in the thread. The process that reads the queue and carries out approved work does not carry standing credentials. The keys to the CRM, the publishing platform, the email system — none of them live inside the bot. They sit in the platform’s secret store and are handed to the action at the moment it runs, scoped to that job.
This sounds like plumbing, but for an agency it is the difference between safe and reckless. The component most exposed to the outside world — the thing listening to a chat channel — is the component holding the least. If that surface were ever compromised, there is no client’s API key sitting in it to steal. We built it that way before it was convenient, because client trust is the entire business.
What surprised us
A request is a better unit than a conversation. “Draft the launch email and three follow-ups” is how people actually delegate. Framing the work as a request instead of a chat changed how the team used it — less hand-holding, more handing-off.
Visible beats private. Because the work happened in a shared channel, anyone could see what was asked and what came back. Private AI sessions create shadow work nobody can review. Doing it in the open made it auditable by default.
The approval step wasn’t a bottleneck. It was the product. We expected the human sign-off to feel like friction. Instead it was the thing that let us trust the output enough to send it to a client at all.
What Claude Tag changes for us
What Claude Tag changes for us.
Anthropic just productized the surface we’d been hand-building: a Slack-native teammate, multiplayer per channel, with an ambient mode and cross-channel learning, running on Opus 4.8. For our internal team, that’s a gift — we can adopt it and retire some of our own scaffolding.
For client delivery, the hard and valuable part is still ours to own: keeping each client’s context walled off from every other, and keeping a human on the ship button. Those two things are exactly what Claude Tag’s best features work against by default — which is the whole subject of the next piece: Claude Tag for Agencies: The Multi-Client Isolation Trap. For the full picture, go back to the pillar: Claude Tag: A Builder’s Guide for Agencies.
