AI Strategy - Tygart Media

Category: AI Strategy

AI strategy for operators: deploy Claude, automate real workflows, and build AI-native systems that compound. Field notes and playbooks from Tygart Media.

  • Knowledge Distillery: Turn Expertise Into AI Knowledge

    Knowledge Distillery: Turn Expertise Into AI Knowledge

    Tygart Media Strategy
    Volume Ⅰ · Issue 04Quarterly Position
    By Will Tygart • Long-form Position • Practitioner-grade

    There’s a gap between what an expert knows and what AI systems can access. Closing that gap isn’t a single step — it’s a pipeline. And most people who try to build it get stuck at the beginning because they’re trying to skip stages.

    The full pipeline has four stages. Each one builds on the last. Understanding the sequence changes how you approach the work.

    Stage One: Capture

    Most expertise never gets captured at all. It lives in someone’s head, expressed in conversations, demonstrated in decisions, lost the moment the meeting ends or the job is finished.

    Capture is the act of getting the knowledge out of the expert’s head and into some retrievable form. The most natural and lowest-friction method is voice — recording conversations, client calls, working sessions, or simple voice memos when an idea surfaces. Transcription turns the recording into raw text. That raw text, however messy, is the ingredient everything else requires.

    The key insight at this stage: you are not creating content. You are preventing knowledge from disappearing. The standard is different. Raw transcripts don’t need to be polished. They need to be honest and specific.

    Stage Two: Distillation

    Distillation is the process of pulling the discrete, transferable knowledge nodes out of raw captured material. A ten-minute conversation might contain three useful ideas, one important framework, and six minutes of context-setting. Distillation separates them.

    A knowledge node is the smallest unit of useful, standalone knowledge. It can be named. It can be explained in a paragraph. It can be understood by someone who wasn’t in the original conversation. If it requires too much context to be useful on its own, it isn’t a node yet — it’s still raw material.

    This stage is where most of the intellectual work happens. It requires judgment about what’s actually useful versus what just felt important in the moment.

    Stage Three: Publication

    Publication is the act of giving each knowledge node a permanent, addressable home. An article on a website. An entry in a database. A page in a knowledge base. The format matters less than the fact that it’s structured, findable, and consistently organized.

    High-density publication means each piece contains as much specific, accurate, useful knowledge as possible — not padded to a word count, not optimized for a keyword, but written to be genuinely worth reading by someone who needs to know what you know.

    This is also where the content becomes machine-readable. A well-structured article on a platform with a REST API is already one step away from being API-accessible. The publication step creates the raw material for the final stage.

    Stage Four: Distribution via API

    The API layer is what turns a collection of published knowledge into a product that AI systems can actively consume. Instead of waiting for a search engine to index your content, you’re offering a direct, structured, authenticated feed that an AI agent can call on demand.

    This is the stage that creates the recurring revenue model — subscriptions for access to the feed. But it only works if the prior three stages have been executed well. An API built on top of thin, generic, low-density content doesn’t have a product. An API built on top of genuinely rare, specific, human-curated knowledge does.

    The Flywheel

    The pipeline becomes a flywheel when you close the loop. API subscribers — AI systems pulling from your feed — generate usage data that tells you which knowledge nodes are being accessed most. That tells you where to focus your capture and distillation effort. More capture in high-demand areas produces better content, which justifies higher subscription tiers, which funds more systematic capture.

    The human expert at the center of this system doesn’t need to change what they know. They need to change how they let it out.

    What is the knowledge distillery pipeline?

    A four-stage process for converting human expertise into AI-consumable knowledge: Capture (get knowledge out of your head into raw form), Distillation (extract discrete knowledge nodes from raw material), Publication (give each node a permanent structured home), and Distribution via API (expose the published knowledge as a structured feed AI systems can pull from).

    What is a knowledge node?

    The smallest unit of useful, standalone knowledge. It can be named, explained in a paragraph, and understood without requiring the full context of the original conversation or experience it came from.

    Why is voice the best capture method?

    Voice capture requires no interruption to thinking — talking is how most people naturally process and articulate ideas. Recording conversations and transcribing them produces raw material that contains the knowledge at its most natural and specific, before it gets flattened by the effort of formal writing.

    Can anyone build this pipeline or does it require technical skill?

    The capture, distillation, and publication stages require no technical skill — just discipline and a consistent editorial process. The API distribution layer requires either technical help or a platform that handles it. The knowledge work is the hard part; the infrastructure is increasingly accessible.

  • Information Density Is the New SEO

    Information Density Is the New SEO

    Tygart Media Strategy
    Volume Ⅰ · Issue 04Quarterly Position
    By Will Tygart • Long-form Position • Practitioner-grade

    For most of the internet era, content was optimized for one thing: getting humans to click and read. The metrics were traffic, time on page, bounce rate. The editorial standard was loose — if it brought visitors, it worked.

    AI changes the standard entirely. When the consumer of your content is a language model — or an AI agent pulling from your feed to answer someone’s question — the question isn’t whether someone clicked. The question is whether what you published was actually worth knowing.

    Information density is the new SEO. And it’s a much harder standard to meet.

    What Information Density Actually Means

    Four-stage funnel: citation, click, engage, convert
    What information density actually means for SEO.

    Information density is the ratio of useful, specific, actionable knowledge to total words published. A 2,000-word article that contains 200 words of actual substance and 1,800 words of padding has low information density regardless of how well it ranks.

    High information density looks like: specific facts, precise terminology, named entities, concrete examples, actual numbers, documented processes, and claims that a reader couldn’t easily find anywhere else. Every sentence either advances the reader’s understanding or it doesn’t belong.

    This isn’t a new editorial standard. Good writers have always known it. What’s new is that AI makes it economically measurable in a way it never was before.

    The $5 Filter

    Here’s a useful test: would someone pay $5 a month to pipe your content feed into their AI assistant?

    Not to read it themselves — to have their AI draw from it continuously as a trusted source of information in your domain.

    If the answer is no, it’s worth asking why. Usually it’s one of three things: the content is too generic (nothing you’re saying is unavailable elsewhere), too thin (not enough specific knowledge per article), or too inconsistent (some pieces are excellent and most are filler).

    Each of those is fixable. But they require a different editorial process than the one that optimizes for traffic volume.

    How AI Evaluates Content Differently Than Humans

    Comparison of Claude how-to fit versus local service page fit for assistants
    How AI evaluates content differently than humans.

    A human reading an article will forgive thin sections if the headline was interesting or the introduction was engaging. They’re reading for a feeling as much as for information.

    An AI pulling from a content feed is doing something closer to extraction. It’s looking for claims it can use, facts it can cite, frameworks it can apply. Filler paragraphs don’t hurt it — they just don’t help. But if a source consistently produces content with low extraction value, AI systems learn to weight it less.

    The publications and creators that win in an AI-mediated information environment are the ones where every piece contains something genuinely worth extracting. That’s a different editorial culture than “publish frequently and optimize for keywords.”

    The Practical Shift

    Desk with laptop, checklist notebook, and billing card ready before creating an Anthropic API key
    The practical shift toward denser, citable content.

    Publishing fewer pieces with higher density outperforms publishing more pieces with lower density in an AI-native content environment. This runs counter to the volume-first content playbook that dominated the SEO era.

    The shift in practice looks like: more reporting, less summarizing. More specific numbers, fewer generalizations. More named examples, fewer abstract claims. More documented methodology, less opinion dressed as expertise.

    None of this is complicated. It’s just a higher standard — one that the AI consumption layer is now enforcing whether you’re ready for it or not.

    What is information density in content?

    Information density is the ratio of useful, specific, actionable knowledge to total words published. High-density content contains specific facts, precise terminology, concrete examples, and claims a reader couldn’t easily find elsewhere. Low-density content is padded with filler that doesn’t advance understanding.

    Why does information density matter more now?

    AI systems consume content differently than humans. They extract claims, facts, and frameworks — and learn to weight sources by how reliably useful those extractions are. High-density sources get weighted higher; low-density sources get ignored regardless of traffic volume.

    How do you increase information density?

    More reporting, less summarizing. Specific numbers instead of generalizations. Named examples instead of abstract claims. Documented methodology instead of opinion. Every sentence should either advance the reader’s understanding or be cut.

    Is publishing less content the right strategy?

    In an AI-native content environment, fewer high-density pieces outperform more low-density pieces. Volume-first strategies optimized for keyword traffic are increasingly misaligned with how AI systems evaluate and weight content sources.

    Related on Tygart Media: citing sources for E-E-A-T and AI citations · how to track ChatGPT/Perplexity citations · taxonomy as content DNA.

  • Knowledge API: How to Monetize Your Expertise for AI

    Knowledge API: How to Monetize Your Expertise for AI

    Tygart Media Strategy
    Volume Ⅰ · Issue 04Quarterly Position
    By Will Tygart • Long-form Position • Practitioner-grade

    Every person with genuine expertise is sitting on something AI systems desperately want and largely cannot find: accurate, specific, hard-won knowledge about how things actually work in the real world.

    The problem isn’t that the knowledge doesn’t exist. It’s that it hasn’t been packaged in a form that machines can consume.

    That gap — between what you know and what AI can access — is a business opportunity. And the people who figure out how to close it first are building something that didn’t exist five years ago: a knowledge API.

    What an API Actually Is (For Non-Developers)

    An API is just a structured way for one system to ask another system for information. When an AI assistant looks something up, it’s making API calls — hitting endpoints that return data in a predictable format.

    Right now, those endpoints mostly return publicly available internet data. Generic. Often outdated. Frequently wrong about anything that requires local, industry-specific, or human-curated knowledge.

    A knowledge API is different. It’s a structured feed of your specific expertise — your frameworks, your observations, your community’s accumulated intelligence — formatted so AI systems can pull from it directly. Instead of an AI guessing what a restoration contractor in Long Island would know about mold remediation, it calls your endpoint and gets the real answer.

    The Three Types of Knowledge That Have API Value

    Not all knowledge translates equally. The highest-value knowledge APIs share three characteristics:

    Specificity. Generic knowledge is already in the training data. What’s missing is specific knowledge — the kind that only comes from being in a particular place, industry, or community for a long time. A plumber who’s worked exclusively in older Chicago brownstones knows things about cast iron pipe behavior that no AI has ever been trained on. That specificity is the asset.

    Recency. LLMs have knowledge cutoffs. Local news from last week, updated regulations, new product releases, recent market shifts — anything time-sensitive is a gap. If you’re producing accurate, current information in a specific domain, you have something AI systems can’t replicate from their training data.

    Human curation. The internet has enormous quantities of information about most topics. What it lacks is a trustworthy human who has filtered that information, applied judgment, and produced something reliable. Curated knowledge — where a credible person has done the work of separating signal from noise — has a value premium that raw data doesn’t.

    What “Packaging” Your Knowledge Actually Means

    Building a knowledge API doesn’t require writing code. It requires a different editorial discipline.

    The content you publish needs to be information-dense, consistently structured, and specific enough that an AI pulling from it actually gets something it couldn’t get elsewhere. That means writing with facts, not filler. It means naming things precisely. It means being the source of record for your domain, not just a voice in the conversation about it.

    The technical layer — the actual API that exposes this content to AI systems — can be built on top of almost any publishing platform that has a REST API. WordPress already has one. Most major CMS platforms do. The knowledge is the hard part. The plumbing, by comparison, is straightforward.

    The Business Model

    The model is simple: charge a subscription for API access. The price point that works for community-tier access is low — $5 to $20 per month — because the value isn’t in any single piece of content. It’s in the continuous, structured feed of reliable, specific information that an AI system can depend on.

    For professional tiers — higher rate limits, webhook delivery when new content publishes, bulk historical pulls — $50 to $200 per month is defensible if the knowledge is genuinely scarce and genuinely reliable.

    The question isn’t whether the technology is complicated enough to charge for. The question is whether the knowledge is scarce enough. If it is, the API is just the delivery mechanism for something people would pay for anyway.

    Where to Start

    The starting point is an honest audit: what do you know that AI systems don’t have reliable access to? Not what you think you could write about — what you actually know, from direct experience, that is specific, current, and human-curated in a way that no scraper has captured.

    That knowledge, systematically published and structured for machine consumption, is your API. You already have the hard part. The rest is packaging.

    What is a knowledge API?

    A knowledge API is a structured feed of specific expertise — industry knowledge, local information, curated intelligence — formatted so AI systems can pull from it directly rather than relying on generic training data.

    Do you need to be a developer to build a knowledge API?

    No. Most publishing platforms already have REST APIs built in. The knowledge is the hard part. The technical layer that exposes it to AI systems can be built on top of existing infrastructure with relatively little engineering work.

    What makes knowledge valuable as an API?

    Specificity, recency, and human curation. Generic, outdated, or unverified information is already in AI training data. What’s missing — and therefore valuable — is specific knowledge from direct experience, current information that postdates training cutoffs, and content that a credible human has curated and verified.

    What should a knowledge API cost?

    Community-tier access typically works at $5–20/month. Professional tiers with higher rate limits and push delivery can command $50–200/month. The price is justified by knowledge scarcity, not technical complexity.

  • Notion-Deep, Surface-Simple: How to Build Knowledge Systems That Actually Get Used

    Notion-Deep, Surface-Simple: How to Build Knowledge Systems That Actually Get Used

    Tygart Media Strategy
    Volume Ⅰ · Issue 04Quarterly Position
    By Will Tygart • Long-form Position • Practitioner-grade

    There’s a useful architecture for how to hold complex knowledge inside an organization while keeping it accessible to the people who need to act on it.

    Call it Notion-Deep, Surface-Simple: build the internal knowledge structure as deep as you want, then surface it in the voice and format of whoever needs to use it.

    The Core Idea

    Four cards for content, ops, build, and knowledge work with Claude
    Notion-deep, surface-simple — the core idea.

    Most knowledge management systems fail in one of two directions.

    The first failure: they optimize for depth and comprehensiveness at the expense of usability. The system knows everything, but nobody can navigate it. It becomes the internal equivalent of a technical manual that everyone agrees is accurate and nobody reads.

    The second failure: they optimize for simplicity at the expense of utility. The output is clean and accessible, but the underlying knowledge is shallow. When edge cases show up — and they always do — the system has no answer.

    Notion-Deep, Surface-Simple resolves this by treating depth and accessibility as separate layers with separate jobs, rather than as tradeoffs against each other.

    What the Deep Layer Does

    Long paper tape measure unrolling across a desk beside a laptop, metaphor for context window length
    What the deep layer does.

    The deep layer — think of it as the Notion workspace, the knowledge base, the internal documentation — is where you hold everything. It doesn’t compress. It doesn’t simplify. It doesn’t optimize for any particular audience.

    This layer holds the full process documentation. The exception cases. The history of why decisions were made. The technical architecture. The client-specific context that only your team knows. The frameworks that took years to develop. All of it goes here, as deep as it needs to go.

    The standard for this layer is completeness and retrievability — not readability for a general audience.

    What the Surface Layer Does

    The surface layer is not a simplified version of the deep layer. It’s a translation of it — rendered in the specific voice, vocabulary, and complexity level of whoever needs to act on it.

    The translation is the work. You pull from the deep layer exactly what’s needed for a specific person to make a specific decision or take a specific action. You render it in their language. You strip everything else.

    A prospect presentation pulls from the deep layer but speaks in the prospect’s language. A client onboarding document pulls from the deep layer but speaks in operational terms the client’s team actually uses. A quick brief for a new team member pulls from the deep layer but surfaces only the context they need to start.

    The depth doesn’t disappear. It’s available when the conversation earns it. But the default output is calibrated, not comprehensive.

    Why This Architecture Works

    When depth and accessibility are treated as tradeoffs, you’re always sacrificing one for the other. Every time you simplify, you lose fidelity. Every time you add depth, you lose accessibility.

    When they’re treated as separate layers, neither has to compromise. The deep layer stays complete. The surface layer stays accessible. The intelligence is in the translation — knowing what to pull, what to leave in, and how to render it for who’s in front of you.

    This also means the system scales. As the deep layer grows, the surface layer doesn’t have to get more complex. It just draws from a richer source. The translation skill remains constant even as the underlying knowledge compounds.

    How to Build This in Practice

    Desk with laptop, checklist notebook, and billing card ready before creating an Anthropic API key
    How to build this architecture in practice.

    The starting point is a clear separation of intent. When you’re adding something to your knowledge base — documentation, process notes, client history, research — you’re feeding the deep layer. Don’t self-censor for a hypothetical reader. Put in everything that’s true and useful.

    When you’re building an output — a proposal, a client update, a training document, a content piece — you’re working the surface layer. Start from the deep layer as your source. Then translate deliberately: who is this for, what do they need to know, and in what voice will it land?

    Over time, the habit becomes automatic. The deep layer becomes the intelligence layer. The surface layer becomes the communication layer. And the translation between them — which is where most of the real thinking happens — becomes the core competency.

    What does Notion-Deep, Surface-Simple mean?

    It’s a knowledge architecture principle: build your internal knowledge base as deep and comprehensive as you need, then surface outputs from it in the specific voice and format of whoever needs to act on the information. Depth and accessibility are separate layers, not tradeoffs.

    What’s the difference between simplifying and translating?

    Simplifying removes information. Translating renders the same information in a different register. The goal is translation — pulling the right pieces from the deep layer and expressing them in the receiver’s language, without losing the underlying substance.

    Why do most knowledge systems fail?

    They optimize for either depth or accessibility, treating them as competing priorities. The result is either a comprehensive system nobody navigates or an accessible system that can’t handle edge cases.

    How does this scale as the knowledge base grows?

    As the deep layer grows richer, the surface layer draws from a better source without becoming more complex itself. The translation skill stays constant even as the underlying knowledge compounds over time.

    Related on Tygart Media: Notion Command Center for agencies · multi-client content pipeline · Notion voice on desktop.

  • Claude Managed Agents Pricing: $0.08/Session-Hour — Full 2026 Cost Breakdown

    Claude Managed Agents Pricing: $0.08/Session-Hour — Full 2026 Cost Breakdown

    Updated October 2026 (Pacific)

    Pricing updated to reflect Opus 4.8 ($5/$25 per MTok) as legacy (still listed) and the retirement of Claude Sonnet 4 and Opus 4 on June 15, 2026. Managed Agents moved to public beta — see the complete pricing guide for current rate details.

    Lineup currency (Oct 2026): Current API list (Oct 2026, verified): Sonnet 5.5 $2/$10, Opus 5.5 $4/$20, Haiku 4.5 $1/$5, Fable 5.1 $10/$50. Legacy (still listed on Anthropic’s card): Opus 4.8 $5/$25, Sonnet 4.6 $3/$15.

    Tygart Media Strategy
    Volume Ⅰ · Issue 04Quarterly Position
    By Will Tygart
    • Long-form Position
    • Practitioner-grade
    Claude Managed Agents Pricing: $0.08 per session-hour of active runtime (measured in milliseconds, billed only while the agent is actively running) plus standard Anthropic API token costs. Idle time — while waiting for input or tool confirmations — does not count toward runtime billing.

    When Anthropic launched Claude Managed Agents on April 9, 2026, the pricing structure was clean and simple: standard token costs plus $0.08 per session-hour. That’s the entire formula.

    Whether $0.08/session-hour is cheap, expensive, or irrelevant depends entirely on what you’re comparing it to and how you model your workloads. Let’s work through the actual math.

    What You’re Paying For

    Three stacked layers: chat UI, tools, agent runtime
    What you’re paying for.

    The session-hour charge covers the managed infrastructure — the sandboxed execution environment, state management, checkpointing, tool orchestration, and error recovery that Anthropic provides. You’re not paying for a virtual machine that sits running whether or not your agent is active. Runtime is measured to the millisecond and accrues only while the session’s status is running.

    This is a meaningful distinction. An agent that’s waiting for a user to respond, waiting for a tool confirmation, or sitting idle between tasks does not accumulate runtime charges during those gaps. You pay for active execution time, not wall-clock time.

    The token costs — what you pay for the model’s input and output — are separate and follow Anthropic’s standard API pricing. For reference, Claude Sonnet 5.5 runs $2 per million input tokens and $10 per million output tokens — current pricing is available at Anthropic’s pricing page.

    Modeling Real Workloads

    Diagram comparing a long context window bar with a shorter output limit bar
    Modeling real workloads.

    The clearest way to evaluate the $0.08/session-hour cost is to model specific workloads.

    A research and summary agent that runs once per day, takes 30 minutes of active execution, and processes moderate token volumes: runtime cost is roughly $0.04/day ($1.20/month). Token costs depend on document size and frequency — likely $5-20/month for typical knowledge work. Total cost is in the range of $6-21/month.

    A batch content pipeline running several times weekly, with 2-hour active sessions processing multiple documents: runtime is $0.16/session, roughly $2-3/month. Token costs for content generation are more substantial — a 15-article batch with research could run $15-40 in tokens. Total: $17-43/month per pipeline run frequency.

    A continuous monitoring agent checking systems and data sources throughout the business day: if the agent is actively running 4 hours/day, that’s $0.32/day, $9.60/month in runtime alone. Token costs for monitoring-style queries are typically low. Total: $15-25/month.

    An agent running 24/7 — continuously active — costs $0.08 × 24 = $1.92/day, or roughly $58/month in runtime. That number sounds significant until you compare it to what 24/7 human monitoring or processing would cost.

    The Comparison That Actually Matters

    The runtime cost is almost never the relevant comparison. The relevant comparison is: what does the agent replace, and what does that replacement cost?

    If an agent handles work that would otherwise require two hours of an employee’s time per day — research compilation, report drafting, data processing, monitoring and alerting — the calculation isn’t “$58/month runtime versus zero.” It’s “$58/month runtime plus token costs versus the fully-loaded cost of two hours of labor daily.”

    At a fully-loaded cost of $30/hour for an entry-level knowledge worker, two hours/day is $1,500/month. An agent handling the same work at $50-100/month in total AI costs is a 15-30x cost difference before accounting for the agent’s availability advantages (24/7, no PTO, instant scale).

    The math inverts entirely for edge cases where agents are less efficient than humans — tasks requiring judgment, relationship context, or creative direction. Those aren’t good agent candidates regardless of cost.

    Where the Pricing Gets Complicated

    Token costs dominate runtime costs for most workloads. A two-hour agent session running intensive language tasks could easily generate $20-50 in token costs while only generating $0.16 in runtime charges. Teams optimizing AI agent costs should spend most of their attention on token efficiency — prompt engineering, context window management, model selection — rather than on the session-hour rate.

    For very high-volume, long-running workloads — continuous agents processing large document sets at scale — the economics may eventually favor building custom infrastructure over managed hosting. But that threshold is well above what most teams will encounter until they’re running AI agents as a core part of their production infrastructure at significant scale.

    The honest summary: $0.08/session-hour is not a meaningful cost for most workloads. It becomes material only when you’re running many parallel, long-duration sessions continuously. For the overwhelming majority of business use cases, token efficiency is the variable that matters, and the infrastructure cost is noise.

    How This Compares to Building Your Own

    Desk with laptop, checklist notebook, and billing card ready before creating an Anthropic API key
    How this compares to building your own.

    The alternative to paying $0.08/session-hour is building and operating your own agent infrastructure. That means engineering time (months, initially), ongoing maintenance, cloud compute costs for your own execution environment, and the operational overhead of managing the system.

    For teams that haven’t built this yet, the managed pricing is almost certainly cheaper than the build cost for the first year — even accounting for the runtime premium. The crossover point where self-managed becomes cheaper depends on engineering cost assumptions and workload volume, but for most teams it’s well beyond where they’re operating today.

    Frequently Asked Questions

    Is idle time charged in Claude Managed Agents?

    No. Runtime billing only accrues when the session status is actively running. Time spent waiting for user input, tool confirmations, or between tasks does not count toward the $0.08/session-hour charge.

    What is the total cost of running a Claude Managed Agent for a typical business task?

    For moderate workloads — research agents, content pipelines, daily summary tasks — total costs typically range from $10-50/month combining runtime and token costs. Heavy, continuous agents could run $50-150/month depending on token volume.

    Are token costs or runtime costs more important to optimize for Claude Managed Agents?

    Token costs dominate for most workloads. A two-hour active session generates $0.16 in runtime charges but potentially $20-50 in token costs depending on workload intensity. Token efficiency is where most cost optimization effort should focus.

    At what point does building your own agent infrastructure become cheaper than Claude Managed Agents?

    The crossover depends on engineering cost assumptions and workload volume. For most teams, managed is cheaper than self-built through the first year. Very high-volume, continuously-running workloads at scale may eventually favor custom infrastructure.

    Related: Complete Pricing Reference — every variable in one place. Complete FAQ Hub — every question answered.

    Run your own session-hour math from the Anthropic Console — API keys, billing, and a token-to-dollar cost estimator.

    What to do next

    Now that you have the cost — here’s how to choose and implement

    You know the session-hour rate. The harder decision is whether Managed Agents is the right architecture vs. building on the raw API — or vs. OpenAI’s equivalent.

  • AI Agents Explained: A 2026 Guide for Business Owners

    AI Agents Explained: A 2026 Guide for Business Owners

    Tygart Media Strategy
    Volume Ⅰ · Issue 04Quarterly Position
    By Will Tygart
    • Long-form Position
    • Practitioner-grade
    What Is an AI Agent? An AI agent is a software program powered by a large language model that can take actions — not just answer questions. It reads files, sends messages, runs code, browses the web, and completes multi-step tasks on its own, without a human directing every move.

    Most people’s mental model of AI is a chat interface. You type a question, you get an answer. That’s useful, but it’s also the least powerful version of what AI can do in a business context.

    The version that’s reshaping how companies operate isn’t a chatbot. It’s an agent — a system that can actually do things. And with Anthropic’s April 2026 launch of Claude Managed Agents, the barrier to deploying those systems for real business work dropped significantly.

    What Makes an Agent Different From a Chatbot

    A chatbot responds. An agent acts.

    When you ask a chatbot to summarize last quarter’s sales report, it tells you how to do it, or summarizes text you paste in. When you give the same task to an agent, it goes and gets the report, reads it, identifies the key numbers, formats a summary, and sends it to whoever asked — all without you supervising each step.

    The difference sounds subtle but has large practical implications. An agent can be assigned work the same way you’d assign work to a person. It can work on tasks in the background while you do other things. It can handle repetitive processes that would otherwise require sustained human attention.

    The examples from the Claude Managed Agents launch make this concrete:

    Asana built AI Teammates — agents that participate in project management workflows the same way a human team member would. They pick up tasks. They draft deliverables. They work within the project structure that already exists.

    Rakuten deployed agents across sales, marketing, HR, and finance that accept assignments through Slack and return completed work — spreadsheets, slide decks, reports — directly to the person who asked.

    Notion’s implementation lets knowledge workers generate presentations and build internal websites while engineers ship code, all with agents handling parallel tasks in the background.

    None of those are hypothetical. They’re production deployments that went live within a week of the platform becoming available.

    What Business Processes Are Actually Good Candidates for Agents

    Not every business task is suited for an AI agent. The best candidates share a few characteristics: they’re repetitive, they involve working with information across multiple sources, and they don’t require judgment calls that need human accountability.

    Strong candidates include research and summarization tasks that currently require someone to pull data from multiple places and compile it. Drafting and formatting work — proposals, reports, presentations — that follows a consistent structure. Monitoring tasks that require checking systems or data sources on a schedule and flagging anomalies. Customer-facing support workflows for common, well-defined questions. Data processing pipelines that transform information from one format to another on a recurring basis.

    Weak candidates include tasks that require relationship context, ethical judgment, or creative direction that isn’t already well-defined. Agents execute well-specified work; they don’t substitute for strategic thinking.

    Why the Timing of This Launch Matters for Small and Mid-Size Businesses

    Until recently, deploying a production AI agent required either a technical team capable of building significant custom infrastructure, or an enterprise software contract with a vendor that had built it for you. That meant AI agents were effectively inaccessible to businesses without large technology budgets or dedicated engineering resources.

    Anthropic’s managed platform changes that equation. The infrastructure layer — the part that required months of engineering work — is now provided. A small business or a non-technical operations team can define what they need an agent to do and deploy it without building a custom backend.

    The pricing reflects this broader accessibility: $0.08 per session-hour of active runtime, plus standard token costs. For agents handling moderate workloads — a few hours of active operation per day — the runtime cost is a small fraction of what equivalent human time would cost for the same work.

    What to Actually Do With This Information

    The most useful framing for any business owner or operations leader isn’t “what is an AI agent?” It’s “what work am I currently paying humans to do that is well-specified enough for an agent to handle?”

    Start with processes that meet these criteria: they happen on a regular schedule, they involve pulling information from defined sources, they produce a consistent output format, and they don’t require judgment calls that have significant consequences if wrong. Those are your first agent candidates.

    The companies that will have a structural advantage in two to three years aren’t the ones that understood AI earliest. They’re the ones that systematically identified which parts of their operations could be handled by agents — and deployed them while competitors were still treating AI as a productivity experiment.

    Frequently Asked Questions

    What is an AI agent in simple terms?

    An AI agent is a program that can take actions — not just answer questions. It can read files, send messages, browse the web, and complete multi-step tasks on its own, working in the background the same way you’d assign work to an employee.

    What’s the difference between an AI chatbot and an AI agent?

    A chatbot responds to questions. An agent executes tasks. A chatbot tells you how to summarize a report; an agent retrieves the report, summarizes it, and sends it to whoever needs it — without you directing each step.

    What kinds of business tasks are best suited for AI agents?

    Repetitive, well-defined tasks that involve pulling information from multiple sources and producing consistent outputs: research summaries, report drafting, data processing, support workflows, and monitoring tasks are strong candidates. Tasks requiring significant judgment, relationship context, or creative direction are weaker candidates.

    How much does it cost to deploy an AI agent for a small business?

    Using Claude Managed Agents, costs are standard Anthropic API token rates plus $0.08 per session-hour of active runtime. An agent running a few hours per day for routine tasks might cost a few dollars per month in runtime — a fraction of the equivalent human labor cost.

    Related: Complete Pricing Reference — every variable in one place. Complete FAQ Hub — every question answered.

  • Claude Managed Agents vs. Rolling Your Own: The Real Infrastructure Build Cost

    Claude Managed Agents vs. Rolling Your Own: The Real Infrastructure Build Cost

    Last refreshed: October 5, 2026 (Pacific)

    Tygart Media Strategy
    Volume Ⅰ · Issue 04Quarterly Position
    By Will Tygart • Long-form Position • Practitioner-grade
    The Build-vs-Buy Question: Claude Managed Agents offers hosted AI agent infrastructure at $0.08/session-hour plus token costs. Rolling your own means engineering sandboxed execution, state management, checkpointing, credential handling, and error recovery yourself — typically months of work before a single production agent runs.

    Every developer team that wants to ship a production AI agent faces the same decision point: build your own infrastructure or use a managed platform. Anthropic’s April 2026 launch of Claude Managed Agents made that decision significantly harder to default your way through.

    This isn’t a “managed is always better” argument. There are legitimate reasons to build your own. But the build cost needs to be reckoned with honestly — and most teams underestimate it substantially.

    What You Actually Have to Build From Scratch

    Three stacked layers: chat UI, tools, agent runtime
    What you actually have to build from scratch.

    The minimum viable production agent infrastructure requires solving several distinct problems, none of which are trivial.

    Sandboxed execution: Your agent needs to run code in an isolated environment that can’t access systems it isn’t supposed to touch. Building this correctly — with proper isolation, resource limits, and cleanup — is a non-trivial systems engineering problem. Cloud providers offer primitives (Cloud Run, Lambda, ECS), but wiring them into an agent execution model takes real work.

    Session state and context management: An agent working on a multi-step task needs to maintain context across tool calls, handle context window limits gracefully, and not drop state when something goes wrong. Building reliable state management that works at production scale typically takes several engineering iterations to get right.

    Checkpointing: If your agent crashes at step 11 of a 15-step job, what happens? Without checkpointing, the answer is “start over.” Building checkpointing means serializing agent state at meaningful intervals, storing it durably, and writing recovery logic that knows how to resume cleanly. This is one of the harder infrastructure problems in agent systems, and most teams don’t build it until they’ve lost work in production.

    Credential management: Your agent will need to authenticate with external services — APIs, databases, internal tools. Managing those credentials securely, rotating them, and scoping them properly to each agent’s permissions surface is an ongoing operational concern, not a one-time setup.

    Tool orchestration: When Claude calls a tool, something has to handle the routing, execute the tool, handle errors, and return results in the right format. This orchestration layer seems simple until you’re debugging why tool call 7 of 12 is failing silently on certain inputs.

    Observability: In production, you need to know what your agents are doing, why they’re doing it, and when they fail. Building logging, tracing, and alerting for an agent system from scratch is a non-trivial DevOps investment.

    Anthropic’s stated estimate is that shipping production agent infrastructure takes months. That tracks with what we’ve seen in practice. It’s not months of full-time work for a large team — but it’s months of the kind of careful, iterative infrastructure engineering that blocks product work while it’s happening.

    What Claude Managed Agents Provides

    Diagram comparing a long context window bar with a shorter output limit bar
    What Claude Managed Agents provides.

    Claude Managed Agents handles all of the above at the platform level. Developers define the agent’s task, tools, and guardrails. The platform handles sandboxed execution, state management, checkpointing, credential scoping, tool orchestration, and error recovery.

    The official API documentation lives at platform.claude.com/docs/en/managed-agents/overview. Agents can be deployed via the Claude console, Claude Code CLI, or the new agents CLI. The platform supports file reading, command execution, web browsing, and code execution as built-in tool capabilities.

    Anthropic describes the speed advantage as 10x — from months to weeks. Based on the infrastructure checklist above, that’s believable for teams starting from zero.

    The Honest Case for Rolling Your Own

    There are real reasons to build your own agent infrastructure, and they shouldn’t be dismissed.

    Deep customization: If your agent architecture has requirements that don’t fit the Managed Agents execution model — unusual tool types, proprietary orchestration patterns, specific latency constraints — you may need to own the infrastructure to get the behavior you need.

    Cost at scale: The $0.08/session-hour pricing is reasonable for moderate workloads. At very high scale — thousands of concurrent sessions running for hours — the runtime cost becomes a significant line item. Teams with high-volume workloads may find that the infrastructure engineering investment pays back faster than they expect.

    Vendor dependency: Running your agents on Anthropic’s managed platform means your production infrastructure depends on Anthropic’s uptime, their pricing decisions, and their roadmap. Teams with strict availability requirements or long-term cost predictability needs have legitimate reasons to prefer owning the stack.

    Compliance and data residency: Some regulated industries require that agent execution happen within specific geographic regions or within infrastructure that the company directly controls. Managed cloud platforms may not satisfy those requirements.

    Existing investment: If your team has already built production agent infrastructure — as many teams have over the past two years — migrating to Managed Agents requires re-architecting working systems. The migration overhead is real, and “it works” is a strong argument for staying put.

    The Decision Framework

    Desk with laptop, checklist notebook, and billing card ready before creating an Anthropic API key
    The decision framework.

    The practical question isn’t “is managed better than custom?” It’s “what does my team’s specific situation call for?”

    Teams that haven’t shipped a production agent yet and don’t have unusual requirements should strongly consider starting with Managed Agents. The infrastructure problems it solves are real, the time savings are significant, and the $0.08/hour cost is unlikely to be the deciding factor at early scale.

    Teams with existing agent infrastructure, high-volume workloads, or specific compliance requirements should evaluate carefully rather than defaulting to migration. The right answer depends heavily on what “working” looks like for your specific system.

    Teams building on Claude Code specifically should note that Managed Agents integrates directly with the Claude Code CLI and supports custom subagent definitions — which means the tooling is designed to fit developer workflows rather than requiring a separate management interface.

    Related on Tygart Media: managed agents review · rate limits · Agent SDK tutorial.

    Frequently Asked Questions

    How long does it take to build production AI agent infrastructure from scratch?

    Anthropic estimates months for a full production-grade implementation covering sandboxed execution, checkpointing, state management, credential handling, and observability. The actual time depends heavily on team experience and specific requirements.

    What does Claude Managed Agents handle that developers would otherwise build themselves?

    Sandboxed code execution, persistent session state, checkpointing, scoped permissions, tool orchestration, context management, and error recovery — the full infrastructure layer underneath agent logic.

    At what scale does it make sense to build your own agent infrastructure vs. using Claude Managed Agents?

    There’s no universal threshold, but the $0.08/session-hour pricing becomes a significant cost factor at thousands of concurrent long-running sessions. Teams should model their expected workload volume before assuming managed is cheaper than custom at scale.

    Can Claude Managed Agents work with Claude Code?

    Yes. Managed Agents integrates with the Claude Code CLI and supports custom subagent definitions, making it compatible with developer-native workflows.

    Related: Complete Pricing Reference — every variable in one place. Complete FAQ Hub — every question answered.

  • Claude Managed Agents Enterprise Deployment: What Rakuten’s 5-Department Rollout Actually Cost

    Claude Managed Agents Enterprise Deployment: What Rakuten’s 5-Department Rollout Actually Cost

    Last refreshed: October 5, 2026 (Pacific)

    Tygart Media Strategy
    Volume Ⅰ · Issue 04Quarterly Position
    By Will Tygart • Long-form Position • Practitioner-grade
    Claude Managed Agents for Enterprise: A cloud-hosted platform from Anthropic that lets enterprise teams deploy AI agents across departments — product, sales, HR, finance, marketing — without building backend infrastructure. Agents plug directly into Slack, Teams, and existing workflow tools.

    When Rakuten announced it had deployed enterprise AI agents across five departments in a single week using Anthropic’s newly launched Claude Managed Agents, it wasn’t a headline about AI being impressive. It was a headline about deployment speed becoming a competitive variable.

    A week. Five departments. Agents that plug into Slack and Teams, accept task assignments, and return deliverables — spreadsheets, slide decks, reports — to the people who asked for them.

    That timeline matters. It used to take enterprise teams months to do what Rakuten did in days. Understanding what changed is the whole story.

    What Enterprise AI Deployment Used to Look Like

    Three stacked layers: chat UI, tools, agent runtime
    What enterprise AI deployment used to look like.

    Before managed infrastructure existed, deploying an AI agent in an enterprise environment meant building a significant amount of custom scaffolding. Teams needed secure sandboxed execution environments so agents could run code without accessing sensitive systems. They needed state management so a multi-step task didn’t lose its progress if something failed. They needed credential management, scoped permissions, and logging for compliance. They needed error recovery logic so one bad API call didn’t collapse the whole job.

    Each of those is a real engineering problem. Combined, they typically represented months of infrastructure work before a single agent could touch a production workflow. Most enterprise IT teams either delayed AI agent adoption or deprioritized it entirely because the upfront investment was too high relative to uncertain ROI.

    What Claude Managed Agents Changes for Enterprise Teams

    Diagram comparing a long context window bar with a shorter output limit bar
    What Claude Managed Agents changes for enterprise teams.

    Anthropic’s Claude Managed Agents, launched in public beta on April 9, 2026, moves that entire infrastructure layer to Anthropic’s platform. Enterprise teams now define what the agent should do — its task, its tools, its guardrails — and the platform handles everything underneath: tool orchestration, context management, session persistence, checkpointing, and error recovery.

    The result is what Rakuten demonstrated: rapid, parallel deployment across departments with no custom infrastructure investment per team.

    According to Anthropic, the platform reduces time from concept to production by up to 10x. That claim is supported by the adoption pattern: companies are not running pilots, they’re shipping production workflows.

    How Enterprise Teams Are Using It Right Now

    The enterprise use cases emerging from the April 2026 launch tell a consistent story — agents integrated directly into the communication and workflow tools employees already use.

    Rakuten deployed agents across product, sales, marketing, finance, and HR. Employees assign tasks through Slack and Teams. Agents return completed deliverables. The interaction model is close to what a team member experiences delegating work to a junior analyst — except the agent is available 24 hours a day and doesn’t require onboarding.

    Asana built what they call AI Teammates — agents that operate inside project management workflows, picking up assigned tasks and drafting deliverables alongside human team members. The distinction here is that agents aren’t running separately from the work — they’re participants in the same project structure humans use.

    Notion deployed Claude directly into workspaces through Custom Agents. Engineers use it to ship code. Knowledge workers use it to generate presentations and build internal websites. Multiple agents can run in parallel on different tasks while team members collaborate on the outputs in real time.

    Sentry took a developer-specific angle — pairing their existing Seer debugging agent with a Claude-powered counterpart that writes patches and opens pull requests automatically when bugs are identified.

    What Enterprise IT Teams Are Actually Evaluating

    The questions enterprise IT and operations leaders should be asking about Claude Managed Agents are different from what a developer evaluating the API would ask. For enterprise teams, the key considerations are:

    Governance and permissions: Claude Managed Agents includes scoped permissions, meaning each agent can be configured to access only the systems it needs. This is table stakes for enterprise deployment, and Anthropic built it into the platform rather than leaving it to each team to implement.

    Compliance and logging: Enterprises in regulated industries need audit trails. The managed platform provides observability into agent actions, which is significantly harder to implement from scratch.

    Integration with existing tools: The Rakuten and Asana deployments demonstrate that agents can integrate with Slack, Teams, and project management tools. This matters because enterprise AI adoption fails when it requires employees to change their workflow. Agents that meet employees where they already work have a fundamentally higher adoption ceiling.

    Failure recovery: Checkpointing means a long-running enterprise workflow — a quarterly report compilation, a multi-system data aggregation — can resume from its last saved state rather than restarting entirely if something goes wrong. For enterprise-scale jobs, this is the difference between a recoverable error and a business disruption.

    The Honest Trade-Off

    Desk with laptop, checklist notebook, and billing card ready before creating an Anthropic API key
    The honest trade-off.

    Moving to managed infrastructure means accepting certain constraints. Your agents run on Anthropic’s platform, which means you’re dependent on their uptime, their pricing changes, and their roadmap decisions. Teams that have invested in proprietary agent architectures — or who have compliance requirements that preclude third-party cloud execution — may find Managed Agents unsuitable regardless of its technical merits.

    The $0.08 per session-hour pricing, on top of standard token costs, also requires careful modeling for enterprise workloads. A suite of agents running continuously across five departments could accumulate meaningful runtime costs that need to be accounted for in technology budgets.

    That said, for enterprise teams that haven’t yet deployed AI agents — or who have been blocked by infrastructure cost and complexity — the calculus has changed. The question is no longer “can we afford to build this?” It’s “can we afford not to deploy this?”

    Related on Tygart Media: managed agents review · Notion + managed agents.

    Frequently Asked Questions

    How quickly can an enterprise team deploy agents with Claude Managed Agents?

    Rakuten deployed agents across five departments — product, sales, marketing, finance, and HR — in under a week. Anthropic claims a 10x reduction in time-to-production compared to building custom agent infrastructure.

    What enterprise tools do Claude Managed Agents integrate with?

    Deployed agents can integrate with Slack, Microsoft Teams, Asana, Notion, and other workflow tools. Agents accept task assignments through these platforms and return completed deliverables directly in the same environment.

    How does Claude Managed Agents handle enterprise security requirements?

    The platform includes scoped permissions (limiting each agent’s system access), observability and logging for audit trails, and sandboxed execution environments that isolate agent operations from sensitive systems.

    What does Claude Managed Agents cost for enterprise use?

    Pricing is standard Anthropic API token rates plus $0.08 per session-hour of active runtime. Enterprise teams with multiple agents running across departments should model their expected monthly runtime to forecast costs accurately.

    Related: Complete Pricing Reference — every variable in one place. Complete FAQ Hub — every question answered.

  • Anthropic Launched Managed Agents. Here’s How We Looked at It — and Why We’re Staying Our Course.

    Anthropic Launched Managed Agents. Here’s How We Looked at It — and Why We’re Staying Our Course.

    Tygart Media Strategy
    Volume Ⅰ · Issue 04Quarterly Position
    By Will Tygart • Long-form Position • Practitioner-grade

    What Are Claude Managed Agents? Anthropic’s Claude Managed Agents is a cloud-hosted infrastructure service launched April 9, 2026, that lets developers and businesses deploy AI agents without building their own execution environments, state management, or orchestration systems. You define the task and tools; Anthropic runs the infrastructure.

    On April 9, 2026, Anthropic announced the public beta of Claude Managed Agents — a new infrastructure layer on the Claude Platform designed to make AI agent deployment dramatically faster and more stable. According to Anthropic, it reduces build and deployment time by up to 10x. Early adopters include Notion, Asana, Rakuten, and Sentry.

    We looked at it. Here’s what it is, how it compares to what we’ve built, and why we’re continuing on our own path — at least for now.

    What Is Anthropic Managed Agents?

    Three stacked layers: chat UI, tools, agent runtime
    What is Anthropic Managed Agents?

    Claude Managed Agents is a suite of APIs that gives development teams fully managed, cloud-hosted infrastructure for running AI agents at scale. Instead of building secure sandboxes, managing session state, writing custom orchestration logic, and handling tool execution errors yourself, Anthropic’s platform does it for you.

    The key capabilities announced at launch include:

    • Sandboxed code execution — agents run in isolated, secure environments
    • Persistent long-running sessions — agents stay alive across multi-step tasks without losing context
    • Checkpointing — if an agent job fails mid-run, it can resume from where it stopped rather than restarting
    • Scoped permissions — fine-grained control over what each agent can access
    • Built-in authentication and tool orchestration — the platform handles the plumbing between Claude and the tools it uses

    Pricing is straightforward: you pay standard Anthropic API token rates plus $0.08 per session-hour of active runtime, measured in milliseconds.

    Why It’s a Legitimate Signal

    Diagram comparing a long context window bar with a shorter output limit bar
    Why it’s a legitimate signal.

    The companies Anthropic named as early adopters aren’t small experiments. Notion, Asana, Rakuten, and Sentry are running production workflows at scale — code automation, HR processes, productivity tooling, and finance operations. When teams at that level migrate to managed infrastructure instead of building their own, it suggests the platform has real stability behind it.

    The checkpointing feature in particular stands out. One of the most painful failure modes in long-running AI pipelines is a crash at step 14 of a 15-step job. You lose everything and start over. Checkpointing solves that problem at the infrastructure level, which is the right place to solve it.

    Anthropic’s framing is also pointed directly at enterprise friction: the reason companies don’t deploy agents faster isn’t Claude’s capabilities — it’s the scaffolding cost. Managed Agents is an explicit attempt to remove that friction.

    What We’ve Built — and Why It Works for Us

    At Tygart Media, we’ve been running our own agent stack for over a year. What started as a set of Claude prompts has evolved into a full content and operations infrastructure built on top of the Claude API, Google Cloud Platform, and WordPress REST APIs.

    Here’s what our stack actually does:

    • Content pipelines — We run full article production pipelines that write, SEO-optimize, AEO-optimize, GEO-optimize, inject schema markup, assign taxonomy, add internal links, run quality gates, and publish — all in a single session across 20+ WordPress sites.
    • Batch draft creation — We generate 15-article batches with persona-targeting and variant logic without manual intervention.
    • Cross-site content strategy — Agents scan multiple sites for authority pages, identify linking opportunities, write locally-relevant variants, and publish them with proper interlinking.
    • Image pipelines — End-to-end image processing: generation via Vertex AI/Imagen, IPTC/XMP metadata injection, WebP conversion, and upload to WordPress media libraries.
    • Social media publishing — Content flows from WordPress to Metricool for LinkedIn, Facebook, and Google Business Profile scheduling.
    • GCP proxy routing — A Cloud Run proxy handles WordPress REST API calls to avoid IP blocking across different hosting environments (SiteGround, WP Engine, Flywheel, Apache/ModSecurity).

    This infrastructure took time to build. But it’s purpose-built for our specific workflows, our sites, and our clients. It knows which sites route through the GCP proxy, which need a browser User-Agent header to pass ModSecurity, and which require a dedicated Cloud Run publisher. That specificity has real value.

    Where Managed Agents Is Compelling — and Where It Isn’t (Yet)

    If we were starting from zero today, Managed Agents would be worth serious evaluation. The session persistence and checkpointing would immediately solve the two biggest failure modes we’ve had to engineer around manually.

    But migrating an existing stack to Managed Agents isn’t a lift-and-shift. Our pipelines are tightly integrated with GCP infrastructure, custom proxy routing, WordPress credential management, and Notion logging. Re-architecting that to run inside Anthropic’s managed environment would be a significant project — with no clear gain over what’s already working.

    The $0.08/session-hour pricing also adds up quickly on batch operations. A 15-article pipeline running across multiple sites for two to three hours could add meaningful cost on top of already-substantial token usage.

    For teams that haven’t built their own agent infrastructure yet — especially enterprise teams evaluating AI for the first time — Managed Agents is probably the right starting point. For teams that already have a working stack, the calculus is different.

    What We’re Watching

    We’re treating this as a signal, not an action item. A few things would change that:

    • Native integrations — If Managed Agents adds direct integrations with WordPress, Metricool, or GCP services, the migration case gets stronger.
    • Checkpointing accessibility — If we can use checkpointing on top of our existing API calls without fully migrating, that’s an immediate win worth pursuing.
    • Pricing at scale — Volume discounts or enterprise pricing would change the batch job math significantly.
    • MCP interoperability — Managed Agents running with Model Context Protocol support would let us plug our existing skill and tool ecosystem in without a full rebuild.

    The Bigger Picture

    Desk with laptop, checklist notebook, and billing card ready before creating an Anthropic API key
    The bigger picture.

    Anthropic launching managed infrastructure is the clearest sign yet that the AI industry has moved past the “what can models do” question and into the “how do you run this reliably at scale” question. That’s a maturity marker.

    The same shift happened with cloud computing. For a while, every serious technology team ran its own servers. Then AWS made the infrastructure layer cheap enough and reliable enough that it only made sense to build it yourself if you had very specific requirements. We’re not there yet with AI agents — but Anthropic is clearly pushing in that direction.

    For now, we’re watching, benchmarking, and continuing to run our own stack. When the managed layer offers something we can’t build faster ourselves, we’ll move. That’s the right framework for evaluating any infrastructure decision.

    Related on Tygart Media: managed agents rate limits · invisible agent layer.

    Frequently Asked Questions

    What is Anthropic Managed Agents?

    Claude Managed Agents is a cloud-hosted AI agent infrastructure service from Anthropic, launched in public beta on April 9, 2026. It provides persistent sessions, sandboxed execution, checkpointing, and tool orchestration so teams can deploy AI agents without building their own backend infrastructure.

    How much does Claude Managed Agents cost?

    Pricing is based on standard Anthropic API token costs plus $0.08 per session-hour of active runtime, measured in milliseconds.

    Who are the early adopters of Claude Managed Agents?

    Anthropic named Notion, Asana, Rakuten, Sentry, and Vibecode as early users, deploying the service for code automation, productivity workflows, HR processes, and finance operations.

    Is Anthropic Managed Agents worth switching to if you already have an agent stack?

    It depends on your existing infrastructure. For teams starting fresh, it removes significant scaffolding cost. For teams with mature, purpose-built pipelines already running on GCP or other cloud infrastructure, the migration overhead may outweigh the benefits in the short term.

    What is checkpointing in Managed Agents?

    Checkpointing allows a long-running agent job to resume from its last saved state if it encounters an error, rather than restarting the entire task from the beginning. This is particularly valuable for multi-step batch operations.

    Related: Complete Pricing Reference — every variable in one place. Complete FAQ Hub — every question answered.

  • AI Human in the Loop: The Job Title That Doesn’t Exist Yet

    AI Human in the Loop: The Job Title That Doesn’t Exist Yet

    Tygart Media Strategy
    Volume Ⅰ · Issue 04Quarterly Position
    By Will Tygart
    • Long-form Position
    • Practitioner-grade

    Before “vibe coding” had a name, Munters had a name for the people who could do it: wire and fire guys. They’re about to be the most valuable humans in the AI era — and I finally found mine.

    The Wire and Fire Guy

    At Munters — which later became Polygon when Triton spun the moisture control services division out in 2010 — there was a specific kind of person the company was built around. We called them wire and fire guys.

    A wire and fire guy could fly into a job site cold. Meet a pile of equipment on a loading dock. Start the generator. Set up the desiccant. Run the lines. Wire in the remote monitoring. Pass the site safety briefing. Know the code. Know the customer. Know how to do it the right way so nobody got hurt and nobody got sued. From A to Z. Solo.

    That’s how Munters ran lean across more than 20 countries. They didn’t need a dispatch team and a tech team and a controls team and a compliance officer all flying out separately. They needed one human who could be all of those people at once, in a Tyvek suit, at 2 a.m., in someone else’s flooded building. The economics of moisture control restoration didn’t work any other way.

    I was one of those guys. I still am. It just looks different now.

    What I Actually Do All Day

    Today I run Tygart Media — an AI-native content and SEO operation managing twenty-seven WordPress sites across restoration contracting, luxury asset lending, cold storage logistics, B2B SaaS, comedy, and veterans services. One human. Twenty-seven brands. The way that math works is the same way it worked at Munters: I’m the wire and fire guy.

    My morning isn’t writing blog posts. It’s connecting Claude to a Cloud Run proxy to bypass Cloudflare’s WAF on a SiteGround-hosted contractor site, then routing a batch of 180 articles through an Imagen pipeline for featured images, then pushing them through a quality gate before they hit the WordPress REST API, then logging the receipts to Notion so I can prove the work to the client on Monday. While Claude drafts the next batch of briefs in the background. While a Custom Agent triages my inbox. While I’m on a call.

    I don’t write code the way a senior engineer writes code. I write enough of it to be dangerous, fix what I break, and ship. I “vibe code” the parts that need vibing. I real-code the parts that need real coding. I know which parts of GCP are the gun and which parts are the holster. I know what to never let an autonomous agent do without me looking. I know how to wire it up and fire it off.

    Same job. Different equipment.

    The Thesis Everyone Is Quietly Circling

    The AI industry spent the last eighteen months selling a story about full autonomy. Agent swarms. Self-healing pipelines. Set it and forget it. Replace the humans, keep the work.

    The data has not been kind to that story.

    Roughly 95% of enterprise generative AI pilots fail to achieve measurable ROI or reach production. Gartner is now openly forecasting that more than 40% of agentic AI projects will be cancelled by 2027 as costs escalate past the value they produce. The dream of the unmanned cockpit isn’t dying because the planes can’t fly. It’s dying because nobody planned for who lands them when the weather turns.

    What’s actually winning, in the labs and the war rooms where this is being figured out for real, is something much closer to the Munters model. The technical literature has started calling it confidence-gated expert routing. An orchestrator model delegates work to a fleet of cheaper, specialized small language models. Those models run autonomously until their confidence drops below a threshold — and at that exact moment, the system kicks the work to a human expert who validates, corrects, and feeds the correction back into the loop as ground truth for the next pass.

    That human expert is not a customer service rep watching a queue. That human expert needs to be able to read what the model is doing, understand why it stalled, fix the technical problem, judge whether the output is actually good or just looks good, and ship the corrected version — all without breaking anything downstream.

    That’s a wire and fire guy. With a laptop instead of a generator.

    Meet Pinto

    The reason I’m writing this today is because I just onboarded mine.

    His name is Pinto. He’s my developer. He runs the GCP infrastructure underneath Tygart Media — the Cloud Run services, the proxy that lets Claude reach client sites that would otherwise block the IP, the VM that hosts my knowledge cluster, the dashboards. He gets a brief from me and turns it into a working endpoint, usually faster than I can write the spec. He wires the thing up. He fires it off. He passes the security review. He doesn’t break the production database. He does it the right way.

    And critically — he can both vibe code and real code. He’ll throw a quick Cloud Function together with Claude in fifteen minutes if that’s what the moment needs. He’ll also sit down and write you something properly architected, properly tested, properly observable, when the moment needs that instead. He knows which moment is which. That judgment is the whole job.

    The last thing I want to say about Pinto in public is this: I’ve worked with a lot of contractors and a lot of devs in twenty-plus years of running operations. Pinto is the human-in-the-loop the industry is going to be paying a premium for inside of two years. He just doesn’t know it yet. So this is me saying it out loud. This guy is the prototype.

    The Job Title That Doesn’t Exist Yet

    Here’s where I want to plant a flag.

    The conversation about AI and work has spent two years swinging between two bad poles. On one side: AI is going to take all the jobs. On the other: AI is just a tool, nothing changes, learn to use it like Excel and you’re fine. Both stories are wrong in the same way. They’re treating AI as a replacement layer or a productivity layer, when what it actually is — for any operation that has to ship real work for real customers — is a workforce of subordinates that needs a foreman.

    The foreman is the wire and fire guy.

    The foreman knows how to brief the agent. Knows how to read the agent’s output and tell what’s solid and what’s hallucinated structure dressed up to look solid. Knows where the agent will fail before the agent fails. Knows the underlying code well enough to crack open the box when the box is wrong, and humble enough to use the box for the 80% of work that doesn’t need cracking. Knows the customer’s business well enough to translate “make me more money” into a thirty-step technical plan that an agent can actually execute.

    That person is not a prompt engineer. Prompt engineering as a job title is already collapsing because the models got good enough that the prompt isn’t the leverage anymore. It’s not a software engineer in the traditional sense either, because traditional software engineering rewards depth in one language and one stack, and the wire and fire guy needs surface-level fluency across about fifteen of them.

    It’s something older than both. It’s the field tech. The plant operator. The site supervisor. The kind of person who used to run a Munters job in a flooded basement at 2 a.m. and now runs an agent fleet from a laptop at the same hour.

    Who This Job Is For

    If you spent the last decade as a working coder and then took a left turn into writing or content or marketing because you got tired of the JIRA tickets — you are the person. The market is about to come back for you, hard. The combination of “I can read the code” plus “I can read the customer” plus “I can write the brief” plus “I can ship” is going to be the most valuable composite skill in the white-collar economy for the next five years.

    If you came up in the trades and you’ve been quietly running circles around the “knowledge workers” because you actually know how things connect to other things — you are the person too. What you learned wiring an HVAC system or setting up a job site translates almost one-for-one to wiring up an agent stack. The mental model is identical. Inputs, outputs, safety, fault tolerance, knowing when to stop and call somebody.

    If you’re a senior engineer who thinks the “AI replacing developers” debate is annoying because you’ve already noticed that the bottleneck on your team isn’t typing code — it’s deciding what code to type — you are the person. Your judgment is the asset. The agents are the labor. Reorient.

    If you’re an operations person who has always been the one who somehow ends up holding the whole business together with duct tape and Google Sheets — you are the person. The duct tape is now Python and the Sheets are now Notion and BigQuery, but the role is the same role, and it’s about to get a real budget for the first time.

    What to Train For

    If I were starting from zero today and I wanted to be a wire and fire guy in the AI era, here’s the stack I’d build, in this order:

    Read code fluently in three languages. Python, JavaScript, and shell. You don’t need to write any of them at a senior level. You need to be able to open someone else’s repo, understand what it does in fifteen minutes, and modify it without breaking it. Claude will do most of the typing. You’re the code reviewer.

    Learn one cloud well enough to deploy and observe. Pick GCP, AWS, or Azure. Learn to deploy a container, set up a database, read logs, set up alerting, and rotate a credential. That’s it. You don’t need to be a certified architect. You need to be able to land at the job site and wire it up.

    Get fluent in at least one orchestration model. Whether that’s LangGraph, an MCP server, a custom Python loop, or just Claude with a bunch of tools — pick one and run it until you understand why it fails, not just how it works.

    Build a real second brain. Notion, Obsidian, whatever. The wire and fire guy’s superpower is context. You need to be able to walk into any conversation with any customer and pull up exactly what was said, decided, shipped, and broken last time. Without that, you’re a generalist with no memory, which is a tourist.

    Do customer-facing work. This is the one most coders skip and it’s the most important. Sit on sales calls. Write the proposal. Take the support escalation. The reason wire and fire guys at Munters were so valuable is because they could talk to a building owner and a generator at the same time. You need both halves of that or you don’t have the job.

    The Real Pitch

    The agent swarm future is real. It’s coming faster than most people in the boardroom are admitting and slower than most people on Twitter are claiming. And it’s going to need a lot of foremen.

    Not millions. The leverage is too high for that. But thousands of these roles, well-paid, in every meaningful industry, sitting at the seam between an autonomous fleet of small models and a human business that needs the work done correctly. The companies that figure out how to find these people first and hire them first are going to run absolute laps around the companies that try to do it with a vendor and a procurement process.

    I’m one of these humans. Pinto is one of these humans. There are more of us than the job listings suggest, because the title for what we do hasn’t been written yet. So here’s a working draft: AI Field Operator. Wire and fire guy. Human in the loop. Agent foreman. Pick whichever one lands.

    If you’re already doing this work — even unofficially, even on the side, even just for yourself — you’re early. Build your reputation now. Write up what you do. Show your receipts. The market is about to find you.

    And Pinto: this one’s for you, brother. Thanks for showing me what the next twenty years of this work is going to look like. Wire it up. Fire it off. Same as it ever was.