Day 12 April 16, 2026

Agent Economics

Cost-per-task, token optimization, ROI frameworks, and the unit economics that determine whether your agent makes money or burns it

Token Pricing
Model Routing
Prompt Compression
Caching
ROI Frameworks
FinOps for AI
Curriculum
70.6% complete (Day 12 / 17)
Core Concept

Why Agent Cost Is Not Just "API Spend"

Imagine running a brilliant employee who bills by the word — every sentence they read, every word they write, every question they ask costs money. Then imagine they also have to call their colleagues 5 times for every task, those colleagues also bill by the word, and the whole team sometimes goes in circles for 20 rounds before finishing a task. That is what running a production AI agent looks like. Understanding and controlling this cost structure is the difference between an agent product that scales profitably and one that quietly burns cash.

The fundamental equation: Total Agent Cost = Token Cost × Multiplier + Infrastructure + Human Oversight. The token cost is visible and easy to measure. The multiplier — driven by agentic looping, multi-LLM orchestration, error recovery, and verification — is invisible until you look. Human oversight (review, error correction, monitoring) often outweighs token spend by 20–200×. A team that optimizes only token costs while ignoring these other factors is optimizing the wrong thing.

1The Token Pricing Landscape (2026)

LLM inference costs have declined approximately 5–10× per year since 2022 — a pace even faster than Moore's Law. GPT-4 quality inference that cost ~$20/million tokens in late 2022 now costs ~$0.40–2.00/million tokens. This price compression is driven by three overlapping forces: hardware efficiency gains, algorithmic improvements (~3× per year isolated), and competition between frontier labs.

Small/Fast Models
$0.05–0.30
per million tokens. Haiku 3.5, GPT-4o-mini, Gemini Flash. Best for routing, classification, simple QA.
Mid-Tier (Workhorse)
$0.30–3.00
per million tokens. Sonnet 4.6, GPT-4o. Best for agentic tasks, code, reasoning.
Frontier/Reasoning
$3–60+
per million tokens. Opus 4.6, o3, Gemini Ultra. Reserve for hardest sub-tasks only.
Output vs. Input Asymmetry
3–8×
Output tokens cost 3–8× more than input tokens because generation is sequential while input processing parallelizes. A token-efficient agent writes short, dense responses.
Prefix Caching (Anthropic)
~90% off
Cached input tokens cost $0.30/M vs. $3.00/M uncached. Agents with large shared system prompts save 80–90% on repeated calls instantly.
Open Source Inference
2–10×
Self-hosted Llama 3.3 70B or Qwen2.5-72B runs at 2–10× lower cost at scale, with zero marginal token pricing. Operational overhead is the tradeoff.
The critical asymmetry: output tokens are expensive because the GPU generates each token serially, attending to all previous tokens. This is why "show your reasoning" system prompts that force long chain-of-thought dramatically increase costs. Extended Thinking modes on Claude can produce thousands of output tokens of reasoning before the visible response — budget for this explicitly.

2The Agentic Cost Multiplier

The single most dangerous economic fact about agents: agentic systems cost 5–25× more per task than direct chat completions doing the same job. A $0.01 chat API call becomes $0.10–0.50 in an agentic workflow. Why?

User Query
1 call, cheap
→
Planning
1–3 calls
→
Tool Use × N
3–10 calls
→
Verification
1–3 calls
→
Response
1 call

Every step re-injects the full context — including tool results, prior reasoning, and the system prompt — so token count grows quadratically with the number of turns. A 10-turn agent loop where context doubles each time produces roughly 1,000× the token count of a 1-turn call. Context window management (summarization, compaction) is therefore a core cost-control lever, not just an engineering convenience.

Three compounding effects engineers often miss: (1) Failure recovery — when a tool call fails, the agent retries with more context, escalating both token count and latency. A 10% tool failure rate with retry logic adds 20–40% to average task cost. (2) Verification overhead — well-designed agents check their own work, adding 1–2 extra LLM calls per task. (3) Multi-agent fan-out — orchestrator + 4 subagents each with their own system prompt multiplies token spend before a single tool is called.

Real-world benchmark: An agent handling a typical SWE-bench task (edit code, run tests, iterate) consumes $5–8 in API fees at mid-tier model pricing. At 1,000 tasks/day, that is $5,000–8,000/day or $1.8M–2.9M/year in inference alone — before infrastructure, human review, or monitoring. Model selection and optimization are not optional at this scale.

3The Five Optimization Levers

Cost optimization for agents is a portfolio problem — each lever has different effort, impact, and risk profiles. Engineers who ship production agents by 2026 typically implement all five in sequence:

1 · Model Routing
Route tasks to the cheapest model capable of handling them. Use a fast classifier to predict required capability, then dispatch: simple queries → Haiku, complex reasoning → Sonnet, hard research → Opus. Industry standard by 2025.
Cost reduction: 60–87%
2 · Prefix Caching
Structure prompts so the static portion (system prompt, shared context, documentation) comes first. Anthropic caches prefix blocks at $0.30/M vs. $3.00/M — a 90% discount with zero quality impact. OpenAI, Google offer similar.
Cost reduction: 40–80% on repeat calls
3 · Prompt Compression
Use tools like LLMLingua (Microsoft, ~5.7K stars) to compress retrieved documents, RAG chunks, and tool outputs before inserting into context. Achieves 5–20× compression of non-critical content with <5% quality loss on most tasks.
Cost reduction: 30–60% on RAG-heavy agents
4 · Context Compaction
Periodically summarize long agent trajectories rather than carrying full history. Claude Code compacts context automatically when approaching the window limit. Reduces token count by 70–90% for long-horizon tasks while preserving task state.
Cost reduction: 50–80% on long tasks
5 · Output Token Control
Explicitly constrain output length in system prompts ("respond in <200 words"), use structured output formats (JSON schemas), and avoid prompts that trigger extended chain-of-thought when not needed. Most effective at reducing surprise bills.
Cost reduction: 20–50% on verbose agents
6 · Observability First
Use tools like LiteLLM (~43K stars), Langfuse (~23K stars), or Helicone (~5.2K stars) to instrument every LLM call with model, tokens, latency, and cost. You cannot optimize what you cannot see — blind deployment is how enterprise teams discover $10M/month surprise bills.
Foundation for all other optimizations
Order of operations matters. Implement observability first (you need the data), then caching (highest impact, zero quality loss), then routing (high impact, requires classifier), then compression (moderate impact, requires evaluation), then output controls (quick wins). Teams that skip straight to prompt compression without caching often leave 80% savings on the table.

4ROI Framework: The Right Metric Is Not Cost-Per-Token

The metric that governs whether an agent product is economically viable is reliability-adjusted cost-per-successful-task (RACPST). Many teams optimize cost-per-token while ignoring the other variables that make or break agent economics:

RACPST = (Token Cost + Infrastructure Cost + Human Oversight Cost) / (Task Volume × Success Rate)

A 60% cheaper model that reduces task success rate from 85% to 70% increases RACPST by 6%. A 90% success rate agent with premium model costs less per successful outcome than a 65% success rate agent with a cheap model, even if raw API spend is 40% higher. Build ROI cases on successful outcomes, not on raw API spend.

The human oversight ratio is the most commonly underestimated term. In enterprise deployments, the cost of humans reviewing, correcting, and auditing agent outputs typically runs 20–200× the inference spend. A task that requires a human correction 10% of the time, where each correction takes 15 minutes at $80/hour loaded cost, adds $2.00 in human cost per task — which often exceeds the entire API cost.

Standard ROI calculation for replacing a human workflow: a sales intelligence agent saving 10 hours/week across 15 sales reps recovers ~$15,000/week in productive time (at $100/hour loaded cost), which pays back a $150,000 development investment in 10 weeks. The agent's total inference cost at $500/week is not the governing constraint — the payback math works even at 10× that token spend.

The $19 trillion insight: Lightspeed Venture Partners identified that the global economy has $19 trillion in annual work that agents can potentially address. At even 1% penetration with 10% cost reduction per task, the economic value creation dwarfs any current LLM API budget. The constraint is not token cost — it is building agents reliable enough that businesses trust them with real work.
Papers to Know

Landmark Research on Agent Cost and LLM Economics

Seminal ACM EC 2025
The Economics of Large Language Models: Token Allocation, Fine-Tuning, and Optimal Pricing
Dirk Bergemann, Alessandro Bonatti, Alex Smolin — arXiv:2502.07736 (February 2025)
This paper brings rigorous microeconomic theory to LLM pricing for the first time. It develops a mechanism design framework where a provider sells menus of token budgets to users with heterogeneous valuations across a continuum of task types. Under a homogeneous production technology, users' multi-dimensional type profiles collapse to a scalar index, reducing the problem to classical one-dimensional screening. The optimal contract takes the form of committed-spend agreements: users pay for a budget they allocate across token classes (input vs. output) priced at marginal cost. The analysis also covers multi-model environments and competition between proprietary frontier models and open-source alternatives.
Why it matters: This is the first formal economic treatment of why token-based pricing exists and why it is (or isn't) optimal. It explains the persistent input/output price asymmetry and predicts that open-source competition reshapes compute provision at both intensive and extensive margins — exactly what we've seen with Llama, Qwen, and Mistral in 2024–2025. Engineers and product leaders who understand this paper can anticipate pricing moves by frontier labs.
arxiv.org/abs/2502.07736
Recent arXiv 2025
The Price of Progress: Algorithmic Efficiency and the Falling Cost of AI Inference
Hans Gundlach, Jayson Lynch, Matthias Mertens, Neil Thompson (MIT) — arXiv:2511.23455 (November 2025)
A rigorous empirical decomposition of why LLM inference costs have fallen so dramatically. The paper uses data from Artificial Analysis and Epoch AI to show that the price for a given benchmark performance level has fallen approximately 5–10× per year across knowledge, reasoning, math, and software engineering benchmarks. It isolates three contributing forces: (1) economic/competition effects from multiple providers, (2) hardware efficiency improvements (chip generation advances), and (3) algorithmic efficiency improvements. Isolating the open-source models to remove competition effects, algorithmic progress alone contributes approximately 3× cost reduction per year.
Why it matters: This is the most rigorous data-driven estimate of the AI inference cost curve. The ~3× annual algorithmic improvement means that in three years, the same model capability will cost ~1/27th of today's price purely from algorithmic progress, even without hardware improvements or competition effects. Every business case built on agent economics should model this curve explicitly rather than assuming static costs.
arxiv.org/abs/2511.23455
Recent arXiv 2025
Efficient Agents: Building Effective Agents While Reducing Cost
Ningning Wang, Xavier Hu, Pai Liu, He Zhu, et al. (OPPO PersonalAI, 14 authors) — arXiv:2508.02694 (August 2025)
The first systematic study of the efficiency–effectiveness trade-off in modern agent systems. Using the GAIA benchmark, the paper empirically investigates three questions: How much complexity do agentic tasks inherently require? When do additional orchestration modules yield diminishing returns? How much can efficient framework design reduce cost without sacrificing performance? Key findings include that backbone model selection drives most of performance (choosing the right tier matters more than framework choice), many added modules yield less than 2% accuracy gain while doubling cost, and targeted framework optimizations achieved a 36.9% reduction in average token usage with a 36.2% reduction in median cost per problem.
Why it matters: Provides the first empirical data on when "more is more" vs. "more is just more expensive" in agent system design. The diminishing returns findings challenge the instinct to add more orchestration, more verification, and more sub-agents — and provide a methodological blueprint for running cost-efficiency analyses on your own agentic workloads.
arxiv.org/abs/2508.02694
GitHub Pulse

The Cost Optimization Ecosystem

BerriAI/litellm HOT ~43K ⭐
Python SDK + proxy gateway for 100+ LLM APIs with built-in cost tracking, spend limits, model routing, and per-key budget controls.
Architectural interest: the de facto standard for multi-model cost management. Its virtual key system lets teams set per-project spend caps, and its spend tracking dashboard is what most FinOps teams build around. Integrates with Langfuse and Helicone for observability.
langfuse/langfuse GROWING ~23K ⭐
Open-source LLM engineering platform with tracing, cost attribution, evals, prompt management, and cost-per-trace dashboards.
Architectural interest: crossed 10K stars in April 2025, reached 23K by mid-2025, showing explosive adoption. Provides the granular per-prompt, per-session cost breakdowns that reveal which parts of an agent workflow are expensive — often the answer is surprising.
microsoft/LLMLingua ~5.7K ⭐
EMNLP 2023 / ACL 2024 — prompt compression achieving up to 20× context reduction with minimal quality loss using a trained small model as compressor.
Architectural interest: the core innovation is using a cheap small LLM (BERT-scale) to score token importance, then dropping low-importance tokens before sending to the expensive frontier model. The compressed prompt runs through the full model without decompression — no decoding step needed.
Helicone/helicone OPEN SOURCE ~5.2K ⭐
LLM observability proxy — one line of code change captures every call, token count, latency, and cost across providers.
Architectural interest: works as a pass-through proxy (change your base URL, get full observability immediately). YC W23 company. Built on Cloudflare Workers + ClickHouse for <80ms overhead at any scale. The fastest way to make agent spend visible without a major engineering investment.
ZLKong/Awesome-Collection-Token-Reduction actively maintained
Curated collection of token reduction techniques — pruning, merging, clustering, KV-cache compression, and speculative decoding.
Architectural interest: covers the full hierarchy from post-training (GPTQ, AWQ quantization), to inference-time (token merging, KV cache compression), to prompt-level (compression, retrieval-augmented reduction). Useful as a map of the field when evaluating optimization options.
OPPO-PersonalAI/OAgents NEW actively maintained
Reference implementation from "Efficient Agents" paper — empirical test bed for efficiency-effectiveness trade-off experiments on GAIA benchmark.
Architectural interest: the only open-source implementation that systematically benchmarks different agent framework choices against both performance AND cost simultaneously. Run your own ablations to find which modules in your pipeline have negative ROI.
Community Pulse

What KOLs Are Saying (Recent)

K
Andrej Karpathy
@karpathy — ex-OpenAI, ex-Tesla
"With the coming tsunami of demand for tokens, there are significant opportunities to orchestrate the underlying memory+compute just right for LLMs. The fundamental and non-obvious constraint is that due to the chip fabrication process, you get two completely distinct pools of [memory and compute]..."
Source: x.com/karpathy/status/2026452488434651264 — Karpathy has argued consistently that the inference cost structure is hardware-constrained in a non-obvious way: HBM (fast, expensive memory) and DRAM (slow, cheap memory) are architecturally separate, and the KV-cache bottleneck that drives agent costs stems directly from this physical constraint. The 2025 LLM Year in Review post is essential reading for understanding where cost reductions will come from next.
HC
Harrison Chase
@hwchase17 — CEO, LangChain
[On context engineering as the governing constraint for long-horizon agents]: "Context Engineering... the models out there are extremely intelligent. But even the smartest human won't be able to do their job effectively without the context of what they're being asked to do."
Source: x.com/hwchase17/status/1933278290992845201 — Chase has consistently argued that context engineering — what information you put in the prompt and when — determines both quality and cost simultaneously. This is a reframing of "prompt engineering" as a first-class architectural concern. At the Sequoia podcast in 2025, he described context engineering as the key to making long-horizon agents economically viable: get the context right and you avoid expensive retry loops.
SW
Simon Willison
@simonw — Creator of Datasette, llm CLI
[Paraphrased from simonwillison.net/tags/llm-pricing/]
Willison has been systematically tracking LLM pricing changes across providers since 2023, documenting the 10× annual cost reductions with specific data. He has argued that the falling cost curve makes previously uneconomic use cases viable on a 6–12 month rolling horizon — a workflow that cannot be justified today at $3/million tokens may be easily justified at $0.30/million next year. His practical guidance on agentic engineering patterns emphasizes measuring actual token usage before optimizing.
LS
Lightspeed Venture Partners
Investment memo — "The AI Agent Economy Has a $19 Trillion Problem"
[Investment thesis, not a personal quote]
Lightspeed's thesis on their investment in Paid (agentic payments) frames the core economic problem: $19 trillion in annual labor represents the addressable market for autonomous agents. The bottleneck is not inference cost — it is trust, reliability, and the payment/transaction infrastructure for autonomous agent actions. This reframes the "agent economics" problem from "how do we make API calls cheaper" to "how do we build agent systems reliable enough to operate commercially unsupervised."
Platform Deep-Dive

How Major Platforms Implement Agent Economics

Platform Cost Architecture Key Optimization Feature Gotcha
Claude / Anthropic Input: $3/M, Output: $15/M (Sonnet 4.6). Cached input: $0.30/M. Extended Thinking billed as output tokens. Prompt Caching (prefix): cache blocks of 1,024+ tokens, instant 90% discount on cached reads. Critical for agents with large system prompts or shared documentation. Extended Thinking tokens are expensive. A thinking budget of 10,000 tokens at $15/M adds $0.15 per call. Set explicit budgets or use standard mode for routine tasks.
OpenAI / GPT-4o GPT-4o: $2.50/M input, $10/M output. Mini: $0.15/M input, $0.60/M output. Context caching available via cached_tokens in API response. Automatic prompt caching on repeated prefixes. Batch API (50% discount for async processing). Structured Outputs (JSON schema) reduces output verbosity significantly. o3 and reasoning model costs can reach $60+/M output tokens. Teams often forget that chain-of-thought reasoning on these models produces large token volumes before the final answer.
Google Gemini Gemini 1.5 Flash: $0.075/M input, $0.30/M output. Ultra: higher tier. 1M+ context window is available but very long contexts cost proportionally more. Context caching via explicit cache creation API — pay once to create a cached context, then use it repeatedly at cache hit pricing. Particularly cost-effective for agents with large knowledge bases loaded per session. The 1M-token context window is a feature and a trap. Naive implementations stuff everything into context and pay full price. Cost-aware design uses selective retrieval into the large context rather than loading everything.
OpenClaw (Claude Code) Consumes Anthropic API tokens. No additional per-seat token markup. Cost is pure API spend at your Anthropic account pricing, visible in Anthropic console. Context compaction is automatic — when approaching the context window limit, Claude Code summarizes prior conversation and tools into a compact representation. Dramatically reduces token usage on long coding sessions. SKILL.md patterns enable cached shared context across sessions. Agents that spawn many subagents (hub-and-spoke) multiply token costs because each spoke has its own full context. Monitor with /cost command in sessions. The 9 CVEs in the ecosystem (covered in Day 14) mostly involve agents making expensive unintended external calls.
Vocabulary

Engineer-Level Definitions

Token Economics
The study of how token-based pricing creates specific incentive structures for LLM providers and users. Distinct from "token costs" (just the dollar amounts). Includes analysis of input/output asymmetries, caching incentives, context window pricing, and the competitive dynamics between proprietary and open-source models.
Avoid: using "token economics" to mean just "API pricing." The economic term implies incentive analysis and strategic behavior by providers.
"The token economics of prefix caching create a strong incentive to structure prompts with shared context first — providers benefit from reduced GPU load and users benefit from a 90% discount."
Reliability-Adjusted CPST
Reliability-Adjusted Cost Per Successful Task. The total cost (tokens + infra + oversight) divided by the number of tasks that actually succeed. The correct metric for evaluating whether an agent is economically viable, as opposed to raw cost-per-call which ignores failure rates.
Avoid: optimizing cost-per-token in isolation — a cheaper but less reliable agent usually has a higher RACPST than a more expensive but more reliable one.
"After switching to the cheaper model, our RACPST actually went up 12% because the failure rate increased from 5% to 22%."
Prefix Caching
A provider-side optimization where the KV-cache (key-value attention states) computed for a shared prompt prefix is stored and reused across multiple API calls. Requires the prefix to be identical and long enough (≥1,024 tokens on Anthropic). Cached reads cost ~10% of uncached reads.
Avoid: confusing with semantic caching (storing LLM outputs and returning them for similar queries — a different technique with different tradeoffs).
"We saved $4,000/month by restructuring our prompts to put the 50,000-token product catalog before the query — prefix caching now handles 90% of our API calls at cached rates."
Model Routing
The practice of dynamically selecting which LLM to use for each individual request or task step, based on a predicted capability requirement. A router classifier (often a small, fast model) scores the incoming query and dispatches to the cheapest model that can handle it with acceptable quality.
Avoid: conflating with load balancing (distributing identical requests across model replicas). Model routing changes which model answers the question, not just which instance.
"Our router sends 70% of queries to Haiku at $0.05/M and 30% to Sonnet at $3/M, achieving 85% cost savings vs. sending everything to Sonnet with <2% quality regression on our eval set."
Prompt Compression
Techniques for reducing the token count of input context — particularly retrieved documents, tool outputs, and conversation history — before sending to a large model. LLMLingua-style compression uses a small language model to score token importance and remove low-scoring tokens. The compressed text is not human-readable but is parseable by the target LLM.
Avoid: treating all text as equally compressible. Structured data (code, JSON, formulas) typically cannot be compressed without data loss; prose and retrieved documents can.
"We apply 5× LLMLingua compression to retrieved documentation chunks before inserting them into the prompt, cutting RAG costs by 60%."
KV-Cache
Key-Value Cache: the stored intermediate attention states (key and value tensors) for processed tokens. Re-using these states instead of recomputing them is what makes prefix caching possible and is also the memory bottleneck that limits context window size. KV-cache grows linearly with sequence length and quadratically with context size in memory terms.
Avoid: assuming all context window positions are equally expensive. The cost to compute the KV-cache for the 100,000th token is the same as for the 1st, but storing it requires proportionally more GPU memory.
"Our agent runs out of GPU memory before it runs out of context length because the KV-cache for our 200K-token system prompt alone occupies 40GB per concurrent request."
Context Compaction
The practice of periodically summarizing long agent conversation histories and tool call results into a condensed representation, replacing the full history in the context window. Different from truncation (which simply cuts old content) — compaction attempts to preserve task-relevant state while dramatically reducing token count. Claude Code performs this automatically.
Avoid: confusing with context window management (just keeping track of what fits). Compaction actively changes the content, not just what portion to include.
"After 50 turns, we trigger context compaction, reducing the 80,000-token trajectory to a 4,000-token summary — costs drop 95% for the remaining turns while task state is preserved."
FinOps for AI
The adaptation of cloud financial operations (FinOps) practices to AI inference spend — treating LLM costs as a managed financial resource with budgets, allocation, optimization, and accountability. Includes per-project cost attribution, spend alerts, efficiency KPIs (cost per successful task), and continuous optimization cycles.
Avoid: treating AI cost management as a one-time optimization. Like cloud FinOps, it requires ongoing culture and process — models, pricing, and usage patterns change continuously.
"Our AI FinOps practice includes weekly cost reviews by product team, per-feature cost attribution dashboards in Langfuse, and a 20% quarterly cost-efficiency target for each agent workload."
Expert Questions

Questions That Signal Deep Understanding

Q1
Your agent's prefix caching hit rate is 85%, but costs are still higher than expected. What's the most likely culprit, and how would you diagnose it?
Q2
You're evaluating switching from Sonnet to a cheaper model for your agent. Sonnet has 87% task success rate; the cheaper model has 72%. At what threshold of cost difference does the switch become economically irrational, assuming human correction costs $2 per failed task?
Q3
A team proposes deploying a multi-agent system with 8 specialized subagents. What economic red flags would you look for in their design before approving the architecture?
Q4
Extended Thinking is improving your agent's task quality from 78% to 91% success rate. The thinking budget costs $0.20 extra per call. At what task volume does adding Extended Thinking become economically justified, assuming human correction costs $3 per failed task?
Q5
The "Price of Progress" paper estimates ~3× annual algorithmic efficiency improvement. How should this fact change your infrastructure investment strategy today versus building for costs to remain constant?
CGO Lens

Agent Economics → Product Strategy for botlearn.ai

How Today's Topic Translates to Product Decisions

Curriculum Tracker

17-Day AI Agent Mastery Program

Day 01Full Agent Stack — ReAct loop, LLM+Memory+Planning+Tools
Day 02Memory Architecture — RAG, 4 memory tiers, MemGPT
Day 03Planning & Tool Use — ReWOO, ToT, MCP, tool schemas
Day 04RAG Deep Dive — chunking, hybrid search, eval metrics
Day 05Agent Frameworks — LangGraph, AutoGen, CrewAI, LlamaIndex
Day 06Benchmarks & Eval — SWE-bench, OSWorld, GAIA, AgentBench
Day 07Multi-Agent Systems — orchestration, trust hierarchies, A2A basics
Day 08Computer Use Agents — GUI automation, accessibility trees, vision
Day 09Code Agents — SWE-agent, Devin, Codex CLI, codebase understanding
Day 10Long-Horizon Tasks — decomposition, checkpointing, failure recovery
Day 11Agent Safety — prompt injection, sandboxing, Constitutional AI
Day 12Agent Economics — cost/task, token optimization, ROI frameworks
Day 13Research Frontiers — self-improvement, meta-learning, open problems
Day 14OpenClaw Deep-Dive — SKILL.md, hub-and-spoke, 9 CVEs, 1184 malicious skills
Day 15A2A Protocols — Agent Cards, OAuth 2.0, inter-agent trust, 50+ partners
Day 16Agentic Commerce — $0.31 avg tx, Stripe MMP, Visa TAP, agent wallets
Day 17Synthesis — building your agent strategy