As an increasing share of our digital interactions go through AI apps, they will intuitively become the most relevant new gateway to commerce.

If agents really are the apps of the AI era, then commerce on these platforms becomes inevitable. The global opportunity could reach $3 to $5 trillion by 2030, and it’s quadrupling year-over-year.

I’ve written previously about what an AI agent actually is and how it works. Here, I want to propose a framework for how the agentic buying experience can evolve. Four stages, each building on prior capabilities: from pure guidance to autonomous orchestration.

Recommends. Initiates. Transacts. Orchestrates.

AI Recommends

AI functions as a smart advisor. You query a model for purchase suggestions; it returns tailored recommendations based on your prompts, preferences, history, and its reasoning.

No transactions executed. Guidance only. In the best cases, a bespoke interface and redirect-to-merchant experience.

This is where most AI-commerce interactions sit today. Generative AI traffic to retail sites grew 4,700% year-over-year by July 2025. 38% of US consumers have used generative AI specifically for shopping, 85% say it improved their experience, and when AI does send shoppers to merchants, they convert 31% better than traffic from traditional channels.

This stage is already reshaping marketing funnels. If product discovery shifts from search engines to AI chat, then SEO, paid advertising, and traditional digital marketing face a fundamental reconfiguration. The structural problem is simple: AIs don’t care about ads. The AI becomes the first touch point, and the business model just doesn’t translate.

But the AI can’t yet act on what it knows. It can recommend the perfect running shoes for your pronation and budget. You still need to complete the checkout. That limitation motivates the next stage.

AI Initiates

Agents begin taking action to start payments. AI tools interact with eCommerce platforms and initiate checkout journeys, though final confirmation stays with the user, one transaction at a time.

This is the current state. And it’s messier than the clean progression might suggest. Three models are emerging:

Browser-use agents. These process your prompt, break it into steps, and execute in a web browser by capturing screenshots and simulating human interaction. OpenAI’s Operator (January 2025) and Anthropic’s Computer Use are the most visible examples. They navigate commerce flows without API access to the merchant. The limitation: they’re clunky, stall on complex sites, and still hand over for payment credentials (besides residing in regulatory and T&Cs compliance grey areas).

Integrated plugins & apps. Merchants develop their own native presence inside the AI platform. Think of it as the App Store model applied to AI commerce: the platform provides distribution and the conversational interface; the merchant keeps their brand, loyalty programs, and checkout experience.

Target built a ChatGPT app where shoppers can buy groceries, link loyalty accounts, and choose fulfillment options. Walmart introduced an in-app service with its own payments. Shopify lets merchants connect storefronts so purchases complete via a branded in-app browser. The merchant retains the customer relationship. The AI is the channel, not the intermediary.

AI platform protocols. Here, the AI platform itself facilitates the transaction through its own protocols. Two architectures are emerging with very different dynamics:

The first is the aggregator model. Perplexity’s “Buy with Pro” expanded to over 5,000 merchants via PayPal in November 2025, with shopping intent queries growing 5x. Here, the AI platform acts as wallet and marketplace: it receives payment from the user, then settles with the merchant in a second transaction. Classic aggregator economics (think food delivery apps, OTAs) applied to AI.

The second is more open. A protocol lets merchants sell through the AI app without marketplace dynamics. OpenAI launched Instant Checkout in ChatGPT in September 2025, powered by Stripe’s Agentic Commerce Protocol. Merchants remain merchants of record. Stripe processes the payment inline, the buyer never leaves the chat, and the protocol handles discovery, cart, and checkout in a standardized way any merchant can plug into.

Conversion remains hard.

By March 2026, OpenAI had to revamp Instant Checkout entirely. Users asked product questions but didn’t buy inside the app. High intent, low conversion. The jump from “advise me” to “buy for me” is harder than it looks.

On the bright side, AI-attributed orders on Shopify grew 11x between January 2025 and March 2026, so the volume is building. But the transition between stages is genuinely difficult.

AI Transacts

Limited but increasing autonomy. Agents can complete transactions in multiple merchants, using open protocols after the user intent is clearly confirmed.

In some cases, they can initiate payments within narrow, predefined parameters without explicit confirmation for each one.

The critical enablers here: open protocols and tokenization.

Unlike the closed-loop models of the previous stage, Transacts sees a shift toward pass-through payment models. Agents interact with open payment networks through tokenized credentials, rather than relying on the AI platform to manage funds in a staged wallet.

Tokenization is the key primitive. In the last twelve months, every major payment player shipped its version.

Visa Intelligent Commerce ships agent-bound tokens with revocable spend limits. Google’s Agent Payments Protocol (AP2, co-created with Amex, 60+ financial institutions) and Universal Commerce Protocol (UCP, with Shopify, Walmart, Target, and 20+ others) standardize the full commerce journey. Stripe launched Shared Payment Tokens. Visa is building a connector on top of them all.

There are ten active agentic commerce protocols in Q2 2026. Ten. The protocol wars, some call it.

A potential user experience: you’re having a conversation with your AI assistant. You ask it to find a birthday gift and a restaurant for dinner. Through back-and-forth, it narrows options across two different merchants. When you’ve settled on choices, the agent presents an explicit summary: “I’d like to purchase the leather wallet from Store A ($85) and reserve a table at Restaurant B ($50 deposit). Total: $135. Shall I proceed?” You confirm once. Transactions execute across both merchants through tokenized credentials. Explicit intent. You never left the chat.

A complementary one: you set permissions upfront and let the agent act within bounds. Maximum spend per transaction ($25). Total budget ($200). Allowlisted merchants in specific categories. Picture a trip to Colorado: you give an agent $1,300 and your preferences. Small purchases ($16 kayaking, $8 trail pass) proceed automatically. Larger ones ($185 cabin) sit pending until you confirm. One interface, many merchants, standard payment rails.

Both modes represent the same stage but different trust postures.

The first is early Transacts: human confirms each purchase, but the agent assembles multi-merchant journeys. The second is late Transacts: the human sets the parameters and the agent executes autonomously within them.

AI Orchestrates

The final stage shows agents managing complex workflows, including purchases and payments, with minimal human input. Beyond discrete transactions, they plan, execute, and iterate over multi-step processes autonomously.

I expect enterprise and B2B to lead here.

Ramp launched AI agents for procurement in 2026: triage requests, source vendors, execute payments. 40% of enterprise applications will feature task-specific agents by end of 2026 (up from less than 5% in 2025), with 90% of B2B buying projected to be AI-intermediated by 2028, pushing over $15 trillion through agent exchanges.

A logistics agent scheduling vehicle maintenance, arranging payments to repair shops, and optimizing fleet downtime.

A marketing agent dynamically monitoring keyword pricing to purchase ad campaigns within a monthly budget.

A procurement agent negotiating with suppliers and executing purchase orders when conditions are met.

These may sound speculative. They are. And also being piloted now.

For consumers, the pattern looks like standing orders executed when criteria align. “Restock my running supplements when the price drops below $X.” “Book the cheapest direct flight to London for any weekend in March under $Y.” The agent monitors permanently and acts when conditions match. No browsing, no comparison shopping, no checkout. You set the intent once; the agent handles the rest.

At this level, agents need three things: an assigned budget (pre-funded or linked to a tokenized credential), access to payment credentials across multiple merchants, and agent identification for secure authentication: authentication must shift from “proving you are the right human” to “proving you are the authorized agent on behalf of the right human.”

Multi-agent orchestration also enters the picture here. An agent negotiating with another agent (or a merchant’s automated system) to find the best price. An agent delegating sub-tasks to specialized agents for research, comparison, and execution.

The double trust gap

A fair objection: this framework describes a direction, but getting there requires trust that hasn’t been earned yet. The gap is double-sided.

On the consumer side: only 24% feel comfortable using AI to complete purchases today. Just 10% have actually bought something using AI in any form. OpenAI’s own Instant Checkout confirmed it: enthusiastic questions, no follow-through to purchase.

On the merchant side: retailers who’ve spent years optimizing checkout, SEO, and acquisition funnels won’t eagerly cede control to AI intermediaries. If the agent becomes the interface, the merchant loses the customer relationship.

The same tension that defined brands vs. marketplaces, hotels vs. OTAs.

Though Shopify, representing millions of merchants, is betting the other way: making every store agent-ready by default. It is true that these types of merchants, unlike major and consolidated retailers, have the most to gain in being discovered by agents.

Even if the timeline is uncertain, the direction looks clearer. The same objections were raised about mobile payments, about buying from unknown sellers on marketplaces, about storing card details online.

Trust followed utility, not the other way around.

What next?

This framework is an imperfect attempt at structuring something evolving fast.

But you might have noticed that several hard problems sit between stages. Payment infrastructure, fraud controls, legal frameworks, and UX patterns: all built around the assumption of a human in the loop. In an AI-led environment, that assumption may no longer hold.

Retailers will need to rethink how to place their brands in an “agent as personal shopper” era. Authentication systems will need to verify software, not biometrics. Dispute resolution will need to account for decisions made by algorithms within user-defined parameters.

That rethinking, and more, will be the focus of the next pieces in this series.

I publish a post a week on key ideas around AI, Agents and everything around their diffusion into the enterprise and people’s lives. You can read them all here.

Subscribe now

The term agent in AI has been used and abused throughout the last couple of years.

Depending on who says it, it may cover a chatbot that answers customer questions, a multi-step workflow that processes invoices, or a swarm of specialized systems coordinating on a complex task.

It is used to refer to simple zero-shot based query systems, as well as complex multi-agent architectures and hybrid systems. The part or the whole. The individual or the conjunction.

Getting the definition right matters. If you are assessing what parts of your business may benefit the most from redesigning them as agentic systems, or evaluating vendor pitches scoping a build. Or even for explaining to an executive what you actually want. You need a working model.

In this week’s piece, I decompose what an AI agent is and what its components are.

What is an agent

In its broadest definition, an agent is a system that can perceive its environment and take action upon it.

That’s it. But there is more...

From the above, an AI agent is characterized by four things: the environment it operates in, how it perceives that environment, its capacity to reason about what it perceives, and the actions it can take.

Consider a customer service agent. Its environment is the product documentation, client data, and chat channel. It perceives through the incoming message and whatever information it retrieves from memory. It reasons by planning a response strategy, evaluating intermediate results, deciding whether to escalate. And it acts by composing a reply, logging the interaction, or handing off to a human.

If the agent is built to play chess, the game and its rules are the environment. If its goal is to write and deploy code, the codebase and its toolchain are the environment.

Unlike simple prompt-response flows, an agent doesn’t just answer a question. It plans, acts, observes the result, and adjusts.

“Workflows are systems where LLMs and tools are orchestrated through predefined code paths. Agents, on the other hand, are systems where LLMs dynamically direct their own processes and tool usage.”

Building effective agents, Anthropic

So, how does an agent accomplish its perception, planning, reasoning, and action capabilities? What makes an agent an agent?

Much like the AI stack, through a five-layer cake of components:

1. Model

In an agent, the AI model is the brain that perceives, reasons and acts.

Generally, a foundation model sits at the core and handles the cognitive work: planning steps to accomplish a task, reasoning about inputs and intermediate outputs, reflecting on action outcomes, calling tools, and deciding when the job is done.

“Planning” refers to specific techniques that have emerged in the research. Chain-of-thought prompting breaks a complex task into sequential reasoning steps. Tree of Thoughts extends this by exploring multiple possible paths before committing to one. And reflection patterns like ReAct (think, act, observe, repeat) allow the model to evaluate its own intermediate results and correct course before proceeding. Just to name a few classical ones.

Well-designed systems decouple planning from execution. The model generates a plan, validates it, then executes step by step. At runtime, the plan can shift in response to what the agent discovers along the way. This also makes it easier to introduce human-in-the-loop validation techniques.

Whether foundation models can truly plan remains actively debated. What practical experience consistently confirms is that larger, more capable models are reliably better at the multi-step reasoning that agentic workflows demand.

Also, in general, agentic systems demand more capable models than simple prompt-response use cases:

• Tool use is hard: selecting the right tool from a growing inventory, constructing correct parameters, and chaining multiple calls is a sophisticated capability that frontier models handle materially better than smaller ones.

• Errors compound: a 10-step process with 99% per-step accuracy still yields only ~90.4% end-to-end success, and at 20 steps you’re down to ~82%.

• Severity is higher: On read operations, an agent can retrieve wrong information and reason confidently over it, producing plausible but incorrect conclusions. On write operations, the damage is material: sent emails, modified databases, deployed code.

2. Context

Context is the agent’s briefing: what it uses to understand a task and perceive its environment at each step. It’s a layered set of instructions, from general to specific, that the agent receives before it starts working and while it runs.

In practice, context follows a hierarchy. At the top sits the system prompt: the permanent instructions that define the agent’s role, constraints, and personality. Below that, tool definitions describe what the agent can do and how each tool should be invoked. Then come memory files (persistent context from prior sessions), conversation history, and finally the current user message. Each layer narrows the focus from “who you are” to “what you’re doing right now.”

Why does this matter? Because models are sensitive to how information is positioned. Reasoning performance degrades by as much as 73% when critical content lands in the middle of long contexts instead of near the beginning or end, a phenomenon researchers call “Lost in the Middle.”

How you structure the briefing is as important as what’s in it. Getting the context architecture right is one of the highest-leverage activities in agent design, and one of the least visible until something breaks.

3. Memory

Memory is how an agent retains, references, and uses information across and within tasks.

An agentic system needs memory to store instructions, examples, plans, tool outputs, and reflections. It operates on three tiers.

Internal knowledge is what the model absorbed during training. Baked in, frozen in time, available in every query. Think of it as the agent’s education (and, like most education, occasionally wrong). It knows what Python is and how HTTP works. It doesn’t know what happened in your codebase last Tuesday.

Short-term memory is the context window itself: the accumulating record of the current conversation, intermediate outputs, and tool results. It lives for the duration of the task. As a session progresses, earlier exchanges become part of this working memory, letting the agent reference what came before.

Context windows have limits. When they fill up, the system compresses or drops older information. Every piece of data in the window competes for the model’s attention.

Long-term memory is externally stored information (databases, vector stores, file systems, static markdown docs) that the agent retrieves as needed. It also can be persisted across tasks and sessions.

Unlike internal knowledge, it can be updated, expanded, and pruned without retraining the model. This is the most actively engineered layer in agent development.

4. Tools

Tools are what give an agent its hands. The set of actions an AI agent can perform is augmented by the tools it has access to.

They enable both perception (reading from the environment) and action (writing to it). A web search tool reads. A code execution tool writes. An API connector does both.

The mechanics: when a model decides it needs to take an action or retrieve information, it generates a structured tool call (specifying which tool and what parameters). The system executes the call, and the result flows back into the agent’s context for the next reasoning step.

This tool-call-result loop is what makes an agent iterative rather than one-shot.

Most model providers now support tool use natively, commonly called function calling.

Tools represent a new kind of software: unlike traditional APIs designed for predictable callers, tools must be legible to a model that will interpret, select, and combine them in ways the designer can’t fully anticipate. Tool descriptions need to be precise (the model reads them to decide which tool to use).

Some examples:

• Knowledge augmentation tools: Web browsing (including search APIs, social media APIs, proprietary interfaces or web parsing), Image retrievers, SQL executors, internal APIs, or Slack connectors.

• Capability extension tools: Calculators, unit converters, code interpreters, other AI models (e.g., ImageGen model), LaTeX compilers, pdf editing tools, OCR library, or Command Line Interfaces (CLIs).

More tools mean more capabilities. But more tools can also hurt performance. A disciplined, well-documented tool inventory often outperforms a sprawling one. You sometimes improve an agent by removing tools, not adding them.

5. Data

Data is the external knowledge an agent accesses at query time. The model’s internal knowledge covers what it learned during training. Long-term memory stores persistent context about the user or environment. Data is the broader pool: the information the agent can search and retrieve on demand.

One of the primary mechanisms is retrieval-augmented generation (RAG). A useful framing: if the model’s training is a closed-book exam, RAG turns it into an open-book one.

The agent queries an external source (a vector database, a search index, a document store), retrieves relevant passages, and feeds them into its context alongside the user’s question. The model then reasons over both the question and the retrieved content to produce its answer.

In more sophisticated systems, the agent doesn’t just retrieve passively. It autonomously constructs queries, evaluates whether results are sufficient, and performs multi-hop retrieval when initial results fall short (this is sometimes called agentic RAG).

There are new and complementary techniques emerging as we go.

For enterprise deployments, where the agent must navigate proprietary documentation, internal wikis, and structured databases, the quality of this data layer often determines whether the agent is useful or merely impressive in demos.

These five components are the core anatomy. Production-grade agents also require observability (tracing what each component produced and why) and evaluation (systematic detection of failures). Both deserve their own treatment.

Practitioners use a term for everything wrapping the LLM: the harness. In other words, what is not the model is the harness. And it can matter more than the quality of the model itself.

When one agent isn’t enough

Some tasks outgrow a single agent. Multi-agent systems combine specialized agents, each with its own model configuration, tool inventory, and defined scope, into coordinated pipelines capable of handling tasks no single agent could manage alone.

Enterprise interest in this space is accelerating. Inquiry volume for multi-agent systems surged 1,445% from Q1 2024 to Q2 2025, and projections suggest that by 2027, 70% of multi-agent deployments will use narrowly specialized agents rather than generalists.

On the one hand, the promise of specialization is that a focused agent can be smaller, faster, and more reliable than a general-purpose one given the same sub-task.

On the other, the risk is complexity. Coordinating multiple agents introduces failure modes (communication overhead, conflicting plans, cascading errors) that can outweigh the benefits.

This deserves its own piece.

Understanding what an agent is and being able to name its parts is a practical skill.

When someone pitches you an “AI agent solution,” you now have five questions: What model? What context? What memory? What tools? What data?

Also, what I described here is the anatomy.

There is another side worth exploring: how the agent actually works at runtime. The orchestration loop that governs step-by-step execution. State persistence across sessions. Error recovery. Guardrails. The physiology, how these components interact when the agent is running.

I’ll save that for a follow-up.

Your company is likely at one of these stages on AI applied to actual business processes and customer experiences:

1. We have a few dozen pilots and proofs-of-concept but nothing is in production or generating any measurable business impact.

2. We need to nail the infrastructure and data setup “first” to enable agents. Not wrong. You’re also not shipping anything.

3. We are working on the methodology “first”. Prioritization frameworks, change management playbooks, ROI templates, governance models. All of the organization scaffolding, none of the building.

4. We’ve given training and access to MS Copilot / ChatGPT / Claude / Gemini to our employees. That’s it, right?

Why does a technology that nearly every executive considers revolutionary and strategic produce measurable financial impact for so few of them?

88% of companies describe AI as important or very important to their strategy. 42% abandoned most of their AI initiatives in the past year, up from 17% the year before. And only 5% generate any meaningful impact on the P&L.

Near-universal strategic buy-in. Rising abandonment. Negligible financial impact1.

I’ve written before about the distance between AI adoption and enterprise value. This piece is about why that distance exists and where most organizations get stuck

The technology isn’t the primary constraint. Current frontier models already perform above the median human level across most knowledge-work tasks. Also, I see firsthand that systems built around it are more than capable enough to run consequential workflows.

The problem is everything that happens before an agent touches a business process.

Here are the seven failure modes that make AI initiatives fail for companies. They’re not mutually exclusive. Most of those struggling with AI may recognize several at once.

1. The awareness gap

The disconnect between decision authority and domain understanding is the awareness problem in its sharpest form. 67% of executives describe their personal AI knowledge as surface-level or below, yet 71% are signing off on AI budget allocations. I wrote about this before.

The issue isn’t general awareness. Most senior leaders at financial institutions have sat through AI briefings, watched demos, and tried ChatGPT. What they haven’t done is build something with it, observe where it fails under real operational conditions, or feel what it’s like when a well-designed agentic workflow completes a task.

That difference between knowing about AI and knowing what it can do for your specific business, is what separates executives who scope viable pilots from those who scope impressive demos.

If you don’t have deep familiarity with what frontier models can do, you can’t identify the high-value use cases in your own domain.

If you don’t know where they fail (hallucination under context overload, inconsistency across domains, degraded performance on low-resource languages, overconfidence when prompted toward a desired answer), you can’t build architecture that accounts for the failures.

Organizations with structured AI literacy programs at the executive level move through the PoC-to-production cycle 40% faster than those relying on organic awareness. The programs that work aren’t courses or slide decks. They’re exposure to functioning systems, inside the organization’s own domain, followed by structured discussion of what was observed and what it would take to replicate it.

2. Technology distrust

A common misconception when discussing AI and Agentic Systems with business leaders is that you just hand an entire process or some part of it over to a Generative AI model. In reality, effective enterprise agentic workflows combine generative AI with deterministic business rules, predictive models, internal functions, company data, external tooling, and structured decision trees.

How much autonomy the model actually has is an architectural choice, and it varies considerably by workflow.

Having said this, risks are real. Accuracy failures can propagate through downstream decisions. Prompt injection can expose systems to malicious inputs. Misconfigured permissions can create economic exposure.

Current frontier models have improved significantly on hallucination rates, but non-trivial failure rates persist, particularly in workflows where precision is non-negotiable. Despite this, only 10% of AI project failures are attributable to algorithm quality or model selection. The technology’s limitations are real, but they account for a small fraction of why projects actually fail.

Professional agentic design significantly reduces these risks.

Agent and context isolation, defensive prompting, structured output formats, and human approval gates are standard practice. A system that, by design, never ingests unvalidated external text has no practical exposure to prompt injection. The risk is architecturally minimized: not hoped away but engineered out.

Other design choices (using the agentic system as a decision recommender that requires human approval, for instance) keep humans in the loop for consequential actions without losing the speed and productivity gains.

The question worth asking: where, specifically, in this workflow does AI judgment add value, and what design choices make that safe? Those are answerable questions.

3. The capability deficit

Most organizations haven’t fully internalized that AI Engineering is a distinct discipline. It’s not a renamed version of the data science or ML engineering roles they already have. The hard problems shift from training and hyperparameter tuning to prompt design, retrieval, agent orchestration, inference optimization, and evaluating open-ended outputs.

Traditional ML engineering starts from data and builds a model. AI Engineering starts from a product or process requirement and makes use of a foundation model (plus other primitives) to meet it. The skillset doesn’t transfer cleanly.

One optimizes the training loop. The other optimizes the deployment loop: prompt design, retrieval quality, output reliability, latency, evaluation at scale. A strong data scientist and a strong AI engineer are solving completely different problems.

Most organizations are years away from having this capability in-house at meaningful depth.

The right move is to work with external partners that already have production track records. Externally built AI systems succeed at roughly twice the rate of internally built ones for complex agentic use cases. You build the internal capability by shipping alongside people who already know how.

Waiting until internal capability exists before deploying anything is the worst option.

4. Excessive centralization

The team that owns a process knows where it breaks, where edge cases cluster, and where time disappears into work that just looks productive. That’s the intelligence that identifies a real use case.

A central AI office sitting three organizational layers above is being asked to do a job that only the people who live inside the processes can do: identifying where AI creates value. Centralizing that step kills the ideation.

It also signals that AI is something the technology team builds for the business rather than something every team owns. Adoption follows identity: if it’s an IT project, business teams don’t feel accountable for outcomes.

A useful heuristic that resolves this: democratize experimentation, govern production.

Let use case identification happen bottom-up, from the teams with the operational knowledge. Central governance earns its role afterwards.

Roughly 6% of companies generate outsized AI returns, and they are 3.6 times more likely to pursue organization-wide transformation than isolated pilots. The structural signature of that 6% combines business-unit-level ownership of ideation with centralized governance of production standards. That’s the dual structure of this heuristic.

5. Fragmentation of efforts

The opposite problem is equally common. Both tend to coexist.

While the CoE builds the constraints nobody asked for, individual business units run their own isolated pilots. None share infrastructure. None are on a path to production. Most will be quietly deprecated within eighteen months. Just, demos.

The experimentation isn’t the problem. What’s dysfunctional is the absence of shared infrastructure, a common data access layer, and a defined path from prototype to production.

Democratize experimentation, govern production. The second half of that heuristic matters as much as the first.

Someone needs to own the agentic tech stack: the architecture standards, the deployment pipelines, the security model, the evaluation framework. Someone needs to decide what gets promoted from prototype to production, and do the engineering work to make it happen.

Either someone owns production or nobody does. And when the answer is nobody, the pilot graveyard grows indefinitely.

6. Tech stack and data availability barriers

An agent is, at its simplest, a system that perceives its environment and acts on it. Therefore, an agent is defined by the environment it operates in and the set of actions it can perform. Both dimensions depend entirely on what the enterprise is willing to expose.

For an agent to generate business value, it needs programmatic access to the company’s data and the ability to execute actions through tools. Those tools may include API calls to internal systems, code execution, document retrieval, connections to other agents, or interactions with external services. The scope of what an agent can do scales directly with the quality of its access.

Legacy on-premises infrastructure is the most common barrier. Data sits in systems designed for human users, not for agents running parallel instances. Permissioning models weren’t built for programmatic operation at scale. In Financial Services specifically, compliance requirements around data access and audit trails add another layer.

Cloud infrastructure makes this materially easier: a serverless function (AWS Lambda, for instance) can trigger an agent run, connect it to a cloud database, and route tool calls through configured gateways, with horizontal scaling and auditability built in.

For organizations running primarily on-premises, the most common adaptation patterns involve three approaches:

1. Read-only database replicas pushed to cloud-accessible endpoints on scheduled intervals, giving agents access to near-current data without touching production systems.

2. API gateway abstraction layers built over legacy systems, allowing agents to call internal tools without direct database access.

3. Sandboxed execution environments where agents run scripts against approved data snapshots.

None of these require a full cloud migration. They’re narrow bridges to specific use cases, and they’re often sufficient to run a first production system on existing infrastructure.

The adaptation doesn’t need to be company-wide before anything gets deployed. If a high-value use case is identified, the architectural investment to make that one workflow run is usually worth making.

7. Organizational resistance

The first six failure modes are technical or structural. This one is human, which makes it harder to address directly.

Roughly 70% of the gap between AI ambition and AI outcomes traces to people and process challenges. The technology and the infrastructure together account for the other 30%.

AI is an emotionally loaded topic for a substantial part of the workforce. The media coverage focused on job displacement, and real layoffs explicitly justified on the basis of AI deployment, have created a credible basis for fear.

The fear has intellectual foundations beyond media coverage. The “Software 2.0” argument (that AI systems will increasingly encode logic in model weights rather than explicit rules) implies that certain knowledge-work roles will genuinely change in character, not just in volume.

On the other hand, employees who regularly use AI tools report increased job satisfaction and reduced cognitive load. The anxiety tracks closely with unfamiliarity, which loops back to the first factor. People who’ve built something with these systems tend not to be afraid of them.

The people most familiar with a process, the ones who would be most valuable in designing an agentic system to handle it, are often the least incentivized to participate. If the outcome of a successful project is the reduction of their team, the rational response is to make the project fail quietly. This happens more often than it gets acknowledged in implementation postmortems.

The probabilistic nature of AI outputs creates a different kind of resistance among business leaders accustomed to deterministic systems. A process that worked 99.7% of the time in auditable, predictable ways is easier to defend in a regulated environment than one that’s right 98% of the time but fails in ways that are harder to reconstruct.

This makes the design of auditability and observability a priority from day one.

There’s no single intervention that eliminates resistance. Three practices might help:

• Insert a technically feasible and reasonable level of transparency about what the system is doing and why at every step.

• Use an explicit human-in-the-loop design for high-stakes decisions.

• Have honest conversations with affected teams before deployment begins rather than after.

None of these create full buy-in. They create enough organizational trust for the first production deployment to happen. That trust, and the evidence that the system works, compounds from there.

If the 70-20-10 breakdown is roughly right, then most of what separates the 5% from the 95% has nothing to do with the models. The models are good enough.

The question is whether an organization has built the human infrastructure to put them to work: the engineering discipline, the governance model, the internal trust, and the executive authority to promote working pilots into production systems.

Most of the failure modes above trace back to a single absence: the internal expertise to bridge the model and the business process, and the organizational structure to act on that expertise once it exists.

I’m not pretending to have all the answers here. Nobody does for something this new. But building that bridge is most of what we do.

At the VCA AI Labs, we design, build, and deploy agentic systems that generate material economic value for financial institutions. Our team has faced these barriers and built around them.

If you operate in financial services and are trying to move from the 95% to the 5%, get in touch.

I publish a post a week on key ideas around AI, Agents and everything around their diffusion into the enterprise and people’s lives. You can read them all here.

Subscribe now

Foundation models are extraordinarily good at knowledge work tasks. And getting better by the quarter.

I’m using the term “tasks” loosely; on purpose. From making a hiring decision, to building a financial model, to editing a strategy deck, to writing a legal brief. Simple or complex, tactical or executive. Tasks are the meat of any professional role. What creates economic value.

And yet, we humans spend an extraordinary amount of time outside the task itself. Depending on the source, between 60% to 80% of a person’s time at work is spent on “work about work”.

The exact number varies by definition. The direction is consistent and damning. More than half of your professional life is not the work. It’s the overhead of doing the work together.

Intuitively, you’d expect that automating tasks through AI would reduce much of this overhead.

If your coding agent can build your new feature in the background, the scrum standup might be unnecessary. If an agent can draft the financial model, maybe you don’t need the three alignment meetings it took to agree on the assumptions. If another agent can monitor and adjust a marketing campaign in real time, maybe the weekly performance standup becomes unnecessary

That intuition is partially right. But it misses something fundamental.

The deployment of AI tools and agentic workflows within the enterprise doesn’t just reduce existing coordination. It creates new forms of it.

Humans need to coordinate with agents. Agents need to coordinate with other agents. And, eventually, agents need to interface with the external world (software, data, other companies’ agents) in ways that carry their own coordination costs.

Hence, Agentic Coordination: the set of interactions, interfaces, and protocols through which humans and AI agents align on intent, exchange information, and manage shared workflows.

For companies thinking about how to deeply integrate AI into their business processes, agentic coordination is an unsolved puzzle with non-standard answers.

What follows is my attempt at a simple mental framework for its dimensions and the current (imperfect) solutions emerging around each.

Human ↔ Agent: The form factors of working together

The chatbot is a surprisingly sticky paradigm.

The reason is simple: coordination is built-in. The back-and-forth nature of a conversational interface organically embeds the feedback loop. Query in, response out, human re-directs, the agent adjusts. It’s not efficient for everything, but the coordination cost is low and intuitive.

The problem is that chat is a terrible fit for a lot of real work. You don’t want to conduct a code review through a chatbot. You don’t want to manage a fleet of marketing campaigns through a conversation thread. And you definitely don’t want to supervise a background research process by sending messages into a void and hoping for the best.

Satya Nadella, Microsoft’s CEO, described an evolution of human-to-agent interaction through a series of form factors that compose together. The framing resonated because it captures something I’ve been observing in the most advanced use case we have right now: coding agents.

If we take coding as the canonical example of knowledge work, and maybe the clearest lighthouse of what’s coming for other workflows, you already see multiple form factors coexisting:

Inline suggestions. The earliest modality. GitHub Copilot tab-completions, autocomplete in your IDE. The agent whispers a suggestion, you accept or reject with a keystroke.

Chat. Request-response, now enhanced with chain-of-thought reasoning where you can see the agent work through the problem. Copilot Chat, ChatGPT, Claude. The coordination mechanism is the conversation itself.

Actions. The agent executes discrete tasks through tool calls, computer use, or MCP server interactions. You issue a command, the agent does something in the world. The coordination shifts from dialogue to delegation.

Foreground agents. Autonomous agents running in your active session, interactively steered. Claude Code in a terminal, Copilot in VS Code. You’re watching, you’re intervening, you’re collaborating in real time.

Background agents. Autonomous agents running asynchronously, in the cloud or locally, without your active supervision. GitHub Copilot Coding Agent, OpenAI Codex, Devin. The coordination happens at checkpoints: you review results after the fact, approve or redirect, then let them continue

Embedded agents. A particular type of background agent deeply integrated into vertical software. The UI itself responds to and triggers agent activity. Think of AI-native SaaS products where the application boundary and the agent boundary blur.

The main point here is that all form factors coexist and compose together.

When coding, you can run a foreground agent, a background agent, and simultaneously edit in VS Code, all happening in parallel.

I imagine this is where professional work broadly is heading. A developer (or analyst, or marketer, or executive) using all of these form factors simultaneously, like a well-tuned orchestra. Locally and in the cloud.

“We macro-delegate and micro-steer. You do a macro delegation, and then I can in parallel give it instructions while it is doing work.” - Satya Nadella

The IDE, with its combination of panels, diff viewers, consoles, and background terminal processes, provided the perfect fertile ground upon which to build a multi-form-factor agentic experience. And even then, it has taken over a year to get the UX roughly right.

How this translates to legal review, financial planning, or marketing operations (domains where quality is subjective and verification is expensive) is, for the moment, heterogeneous and messy.

Consider two directional questions that every organization deploying agents will eventually need to answer:

Agent to human. How does a customer service voice agent summarize its progress and escalate interactions effectively? What is the right format and cadence for a human supervisor to evaluate the agent’s accuracy and judgment? The coordination here is about trust calibration: how much autonomy, how much oversight, and what does the reporting interface look like?

Human to agent. Given an agentic workflow that monitors customer behavior and contextually communicates with them, how does a digital marketing manager track and steer its behavior? The coordination here is about control surfaces: dashboards, override mechanisms, goal-setting interfaces that don’t require the manager to understand the agent’s internal reasoning.

Human in the loop is no longer the only paradigm to think about. Human parallel to the loop, after the loop, or even outside the loop are all valid configurations for specific use cases. Each demands a different coordination UX, a different trust threshold, and different failure modes.

Agent ↔ Agent: The orchestration layer

How AI agents interact with other agents is a rapidly evolving space. And a fascinating one.

Once you move past a single agent performing a single task, you immediately face the classic organizational problem: how do multiple specialized actors coordinate toward a shared goal without stepping on each other, duplicating work, or spiraling into chaos?

The approaches emerging break down roughly into three categories:

Framework-level primitives. Major agentic frameworks now incorporate agent-to-agent coordination as a core feature. Some examples:

• LangGraph models agent workflows as directed graphs with centralized persistent state.

• OpenAI’s Agents SDK offers two clean multi-agent patterns: handoffs for peer-to-peer delegation, and agents-as-tools for centralized orchestration.

• Anthropic’s Claude Agent SDK (the same infrastructure that powers Claude Code, now available to developers) ships with native multi-agent support, including subagents that report to a caller and fully independent agent teammates that coordinate with each other directly.

• CrewAI takes a role-based approach where agents are defined with roles, goals, and backstories.

The specifics vary, but the challenge is the same across all of them. Harrison Chase, LangChain’s CEO, framed it: “When agents mess up, they mess up because they don’t have the right context; when they succeed, they succeed because they have the right context.”

The coordination problem, in other words, is a context engineering problem.

Orchestration platforms. A layer above individual frameworks. Paperclip is probably the most interesting example right now. The mental model is striking: you define a company goal, a CEO agent decomposes it into roles, hires specialized sub-agents (a coder, a marketer, a QA reviewer), and they operate with org charts, budgets, approval gates, and audit trails.

Agent orchestration mirrors organizational design. Reporting lines, budget constraints, governance, accountability. The same problems human organizations have been solving (imperfectly) for centuries.

Interoperability protocols. The protocol stack is consolidating around two complementary standards, both now governed by the Linux Foundation:

• Anthropic’s Model Context Protocol (MCP), announced in late 2024, has become the default standard for connecting agents to tools and data. OpenAI, Google, and Microsoft all adopted it within months.

• Google’s Agent2Agent protocol (A2A), launched in April 2025, focuses on the complementary problem: enabling agents to discover, negotiate with, and delegate to other agents. IBM’s competing Agent Communication Protocol was merged into A2A in August 2025, consolidating the space.

MCP gives agents hands. A2A gives agents the ability to talk to other agents.

The uncomfortable math

The empirical evidence for most multi-agent architectures is sobering. One study found that unstructured (key adjective!) and budget-constrained multi-agent systems amplify errors significantly. For sequential reasoning, every multi-agent variant performed worse than a single well-configured agent.

Another analysis of 1,600+ multi-agent traces found that coordination breakdowns were the single largest failure category.

A sharp analogy to the microservices era captures the risk: we took workable applications, broke them into a confusing cloud of services, then built entire platform teams just to manage the complexity we’d created. The conclusion: most enterprise teams need one well-instrumented agent with clear exit conditions. Not a swarm.

The question, is whether these limitations are structural or temporary. I think most of the technical ones are temporary. But the organizational ones (trust, knowledge preservation, governance design) may not be. Those are human coordination problems.

Agent ↔ External World: A short bridge

There’s a third coordination axis worth acknowledging, even if it deserves its own dedicated exploration: how agents interface with the external world.

MCPs, APIs, CLIs, agentic search, RAG pipelines, computer use, web automation. All are different mechanisms to give agents access to the data, software, and services they need to act

Whether this qualifies as “coordination” in a purist sense is debatable. It’s more like infrastructure. But it shapes how the other two axes work. An agent’s ability to coordinate with a human (or another agent) depends directly on what it can see, touch, and act upon. The richer the external interfaces, the more useful the coordination becomes, and the harder it is to govern.

A wide and deep area. I’ll save it for a future piece.

Orchestra conductors

Satya Nadella coined the metaphor “managers of infinite minds” to describe how humans will relate to AI agents (crediting the concept, he noted, to the CEO of Notion). I like the metaphor. But I’d make one edit.

I think the ideal end state is for humans to become conductors of infinite minds.

The distinction matters. A manager assigns, tracks, and evaluates. A conductor shapes tempo, dynamics, and coherence across an ensemble that is already capable of playing its parts.

We want humans to supervise the loops from a leveraged point, not be in them.” - Ivan Zhao, Steam, Steel, and Infinite Minds

The conductor doesn’t need to know how to play every instrument. But they need an ear for when something is off, a sense for how the parts fit together, and the authority to intervene when the orchestra drifts.

Jensen Huang projects that NVIDIA’s 75,000 employees will work alongside 7.5 million agents within a decade. A 100:1 ratio. At that density, “prompting” is not a skill. Conducting is.

Very few professionals may have the familiarity with these form factors, or the hands-on mastery of orchestrating across them, that the moment demands.

We started with a coordination tax. Sixty percent of a knowledge worker’s time, lost to the overhead of working together. AI agents don’t eliminate that tax. They restructure it. And they demand a new kind of leadership and professional: one that can conduct effectively an orchestra of infinite minds.

Agentic Coordination is a deep dive on the second of the factors limiting the actual generation of economic value from AI. You can read the introductory post here and the deep dive on the first factor, diffusion, here.

I publish a post a week on key ideas around AI, Agents and everything around their diffusion into the enterprise and people’s lives. You can read them all here.

In a previous post, I argued why diffusion might be the key drag for AI to generate notable economic value.

Diffusion, in this context, is defined as the ability and time it takes for AI to permeate through institutions and companies.

For businesses small and large, and of course institutions, this takes much longer than for the individual or series A startup.

Compliance, security, contracting, procurement, provisioning: all those are valid arguments that do drag the adoption of new technology in the enterprise. (Surprisingly, those are tremendously accelerated when a top leader in the organization says so.)

However, I argued that the core reasons are much more intrinsic to human behavior. Specifically three: Awareness, Focus, and Incentives.

“The primary constraints for organizations are no longer model performance or tooling, but rather organizational readiness.” - OpenAI, The State of enterprise AI (2025)

This post lays out the strategies and tactics to make AI diffuse faster and better through your organization, to create meaningful productivity gains as agentic systems and human-agent teams mature.

Forcing awareness

In the post, I defended the thesis that awareness, about the capabilities of top models and tools, is the key brake on its actual permeation into business processes, operations and customer experience.

If you take that at face value then generating that awareness throughout the company and, especially to leadership, should be the obvious point of attack.

If you don’t want to believe it, take a look at the recent OpenAI’s State of Enterprise AI report. Even among active ChatGPT Enterprise users, 19% had never used the data analysis feature, 14% had never used reasoning, and 12% had never tried search (what?).

And I am not even discussing usage, I am talking about real awareness. The kind that makes someone feel the agentic and reasoning capabilities, applied to their own reality.

So how do you generate awareness within your organization?

I would argue that to really assimilate the capabilities of a new technology, you have to go through two phases. First you see it, then you feel it.

The see part should be the easiest, but it’s many times wrongly assumed and overlooked.

Showcasing the highlights

The quickest way to get a leadership team interested, like really interested in AI capabilities, is to bring them the highlights.

Foundation models reached a tipping point somewhere around November 2025 and onwards. The things they can accomplish (and finish) now, particularly in agentic workflows, have nothing to do with the ones they were previously able to do.

But most leaders and managers haven’t seen how.

They need to be exposed explicitly to a show on how far these models, wrapped in agentic architectures, can go.

I don’t think that, at this stage, that should be tailored to your industry. In fact, depending on your sector, it might be counterproductive.

I would take a use case that organically has gotten ahead in advanced agentic loops and make it the highlight. Creating a branded and semi-complex web app in a few minutes is a good example, since coding agents are the lighthouse of progress.

Assuming you have management attributions, organizational influence or just want to make yourself an AI evangelist within your company, you can do these DIY (get some cool demos from enthusiasts online and show them) or get your fav consultant to do it for you.

Making highlights real

Once the seeing step is done, the org needs to feel the tech.

I would do it in two ways:

First, give the leadership team sandboxed access to a frontier agentic tool. The easiest is to provide them with Codex or Claude Code through the desktop apps (terminals and IDEs tend to scare people off) and provide broad guidance on how they can accomplish things, just talking naturally to the thing.

Second, tailor some use cases to the specific industry and verticals within the company’s area of existence. This is particularly effective if you present a demo of the different workflows and what users (internal or clients) will see through them. Again, you can do this yourself, carve out a small squad (of humans or robots) to do this for a couple of weeks or get a consultant.

By the way, although I do think that the first barrier to break is the awareness within the leadership teams, the whole business will definitely benefit from seeing and feeling these. So also take the chance to present it in a company-wide meeting if possible.

Democratizing experimentation

Don’t be cheap.

Give everyone in your team access to, at least one, foundation model. I’m talking basically about the latest Opus, GPT or Gemini Pro. This should be the baseline.

You shall also provide them with access to coding agents and agentic building platforms. Think Claude Code, Codex, Cursor, Replit or MS Copilot Studio. Claude Cowork may work too.

Complement this with links to some basic how-to guides and a generous token budget. Ivan Zhao, the CEO of Notion, and Jensen Huang, CEO of Nvidia, believe that you should, in fact, give them unlimited token budget.

I do agree with them.

Costs are an obvious concern for all companies but, to be honest, the AI momentum does not get infused in everyone at the same time. Most people in your organization probably won’t use their fair share of tokens (this should be tracked, though).

With this, incentivize and let the team surprise you.

On one hand, the people who live with them day to day are the ones that really know their own workflows, processes, and projects. They are the best positioned to translate those into effective AI-powered systems that automate and/or improve them.

On the other hand, you will probably (for sure) have some hidden talent within your company. This might be the avenue for them to shine. And for you to get some awareness again about their brilliance.

The creation of useful AI systems is, by nature, much more bottom-up than top-down.

Host Demo Days, Hackathons, Economic Prizes, revenue sharing schemes, internal venture structures. Pick your mechanism. But do incentivize creation.

Ask for actual demos and the basic technical architecture. Do not settle for slides. Building is thinking.

Governing production

Depending on how regulated your industry is and how critical your business processes, you will need to be much more careful about putting things in production than others, particularly if those workflows touch clients or users directly.

In any case, my strong view is that you need an AI office that governs demand, prioritization and implementation.

Think of it as a project management office for AI initiatives: it owns the agentic tech stack, defines architectural standards, and decides what gets promoted from prototype to production.

Depending on your size, this can be a part-time team member or a full-fledged team. But definitely, companies need a solid and evolving AI and agentic tech stack, as well as consistency in how things are architected and deployed.

Once those great ideas by the team members across the organization have crystallized and have been prioritized, this office should be the one that works on making them production-ready.

Creating space

The most innovative companies in history share a counterintuitive conviction: productivity requires protected unproductivity. This is even more true with AI.

You need to force space into your team members’ schedule for them to experiment with the AI tools you so generously gave them.

From 3M’s 1948 “15% rule” that produced the Post-it Note, to Shopify’s 2025 mandate that employees prove AI can’t do a task before requesting headcount, the most successful enterprises have always carved out structured time, space, and programs for experimentation.

Google’s 20% time is probably the most famous corporate experimentation policy in history and the products attributed to it are genuinely remarkable (Google News, AdSense, Talk, Autocomplete...).

While percentage-based time policies defined one era of innovation, the hackathon model (concentrated bursts of creative autonomy) became equally influential. Companies like Microsoft, Atlassian or Meta have made extensive and successful use of it.

“These one-day bursts of autonomy allow people to work on anything they want, provided they show what they’ve created to their colleagues 24 hours later.” - Daniel Pink, Drive (2009).

That constraint (show what you’ve built) is exactly what separates productive experimentation from aimless tinkering.

Academic evidence strongly supports structured experimentation time.

The playbook of innovation is being rewritten at speed as companies move from encouraging to requiring AI experimentation.

Three tactics stand out for businesses specifically seeking to accelerate AI diffusion:

• Dedicated AI experimentation time (Duolingo’s F-r-AI-days, Shopify’s mandated monthly AI reviews) ensures AI learning is protected from regular work demands.

• AI sandboxes and governed experimentation environments (Okta, Syngenta, AWS Innovation Sandbox) let employees experiment safely without disrupting production systems.

• Visible leadership participation (Tobias Lütke of Shopify coding with AI agents, Brian Armstrong of Coinbase hosting Saturday catch-up sessions, Nicolai Tangen of Norges Bank Investment Management “running around like a maniac”) signals that AI experimentation is a strategic priority, not a passing initiative.

Whether it’s “15% time” or Building Fridays, pick your flavor to make room for experimentation.

Being clear

Resistance is natural in the short term but really unproductive in the long one.

If you are somehow exposed to AI, particularly in the enterprise, you would have heard a lot of buzz around the change management required for AI to actually permeate and generate value.

I think at least 80% of that change management people talk about derives from clarity or lack thereof with the organization members.

My honest opinion: If you have a clear strategy around how AI might make the company more competitive, be clear about it.

For some businesses, it might be an infinite augmentation of productivity (those CEOs mentioned above may fire you for not using your tokens).

For others, it might be creating new markets, new service lines, serving more customers, selling to different customers.

And for others, it might be downsizing and cutting costs to remain competitive. This last category is the most complex to deal with and the most sensitive, but I still argue that being clear is the best path forward.

If you plan to reskill your best team members to become a sort of orchestrator of agents, what do you really gain not being clear about it in the interim?

I get that some motivation downfall might occur in the short term, but you might be missing out on great future talent by not being clear about your expectations and not treating your team members as adults.

I know this is the hardest one. But clarity compounds. Ambiguity doesn’t.

If we assume that synthetic intelligence continues to scale indefinitely, what is then left for human knowledge workers? What are the traits and capabilities that will continue to be valuable after the country of geniuses in a data center is upon us?

A person on my team formulated some variation of that question a few days ago and, after some rambling, I wasn’t able to give even a glimpse of a compelling answer. This is my imperfect attempt to fix that.

This post is different from the others and a bit weirder. You’ve been warned.

Some assumptions first

For the below to make any sense, you have to believe that a few things are true and a few others will be true in the near future (2-4 years).

• Current levels of intelligence of frontier models are enough for a good bunch of knowledge tasks. Another huge chunk will be, once we progressively figure out diffusion, coordination and traces.

• The tooling around those models will keep improving asymmetrically, making agents capable of executing more actions through the digital world.

• Foundation models, LLMs or otherwise, keep getting better following predictable and non-stopping scaling laws.

• Compute is abundant and scaled accordingly to meet demand both in the pre-training and, especially, inference side.

• Energy doesn’t become the bottleneck and AI labs can build, buy, rent or launch the necessary infrastructure to power ever-growing data centers.

• The rest of the stack keeps pace with the above: High-Bandwidth Memory (HBM), data (quality especially through curation and licensing), interconnects or capital markets.

• The cost of inference (making use of the models) does not only not get more expensive but keeps decreasing on a per token basis. Spoiler, the unit cost per token is collapsing in 2026.

Taking the above at face value very likely brings us to a scenario in which we may have at our disposal PhD-level intelligence and capability across thousands of disciplines.

In that world, what skills, traits and talents will be valuable then for humans in knowledge work is a non-trivial question to pose. But what if we aim for an even better one?

In a world of extremely abundant and near-free intelligence, what human capabilities will be even more valuable?

Here are my seven:

1. Judgment

Already the most lucrative human skill, in a world of infinite leverage and commoditized execution, the ability to discern what is worth pursuing, when and why becomes the center of gravity of the new professional.

AI is not capable of setting its own objective function (a.k.a. goals). Unless an algorithmic breakthrough comes along, this will continue to be true.

My definition of wisdom is knowing the long-term consequences of your actions. Wisdom applied to external problems is judgment - Naval Ravikant

Judgment is the amplifier for the traditional trifecta of leverage: code, human labour and capital. If we augment this with synthetic intelligence and agentic execution, it makes it explosively more valuable.

How does one develop judgment? It might take a lifetime, so what the heck would I know? A few ideas:

1. Pick something and master it. Build specific knowledge.

2. Complement that with some worthy experiences: read old books, write daily, build a product (digital or physical), get married, have kids, travel the world, invest your money and drink good wines.

3. Have long walks to think and reflect.

2. Focus

In the age of unlimited leverage, the barriers to starting anything entailing bits and bytes collapse.

In practice, you could spawn up a squad of coding agents to build a web app, an iOS app, an agentic workflow and the copywriting for your marketing materials, today. You can even have them supervised by an agent powered by a better model.

As you can imagine, lots of tech folks are doing that.

But, when you can do anything, you may try to do everything, and get nothing worth it out. Because starting is easy, but finishing is hard.

Lots of people orchestrating teams of agents and building crazy setups never get to launch anything meaningful. Most professional developers embracing AI are, in fact, navigating anxiety, investing too much time in the setup itself and producing semi-functional software.

Therefore, applying judgment to decide and then focusing on a single output until finished becomes a superpower.

Focus gives you speed. Speed is given by AI and focus. The finisher mentality may be the second most important human trait going forward.

3. Optimism

There are, certainly, not a trivial number of unknowns about the development of AI and its societal impacts.

There might be mounting job losses, and entire professions might disappear. Also, an immense amount of power may concentrate in a handful of companies (quite literally a handful).

There are also the implications for geopolitics and warfare, mental health, the energy grid or human relationships. Just to name a few.

I get it.

First, you can’t do anything to fix or mitigate most of the above.

Second, this tech is also the most powerful accelerator you could access in the entire history of humanity. It is quite democratic too. For 20$ a month you can have legion at your disposal. For 200$, an army. And most companies are more than willing to cover the bill for you.

Having a continuously proactive mindset and optimistic lens about AI advancements will be fundamental, especially through the next few years.

Monitoring new improvements, tracking new product launches. Testing them, applying to your work or personal projects. Seeing them as useful tools that may get you where you want to go faster, cheaper.

We have thousands of the most brilliant minds of our generation, enormous piles of cash and (almost) full governments’ support, all working to give us increasing superpowers.

Naive? Maybe. Do you have a more productive alternative?

4. Distribution

The age of infinite leverage is also the age of infinite noise.

You always needed someone listening to what you were saying. Someone at the other end of the channel reading you, buying your products or services, evaluating your work, eyeing what you made.

Call it sales, influence, persuasion, reach.

It might be small and closed-loop (e.g. within your company) or wide and open (e.g. if you are selling something to consumers). But you still need an audience.

I argued that top models now can already do most knowledge work notably well. What they can’t do is make people care. Make people listen.

Distribution is fundamentally a trust game. People follow people. They buy from people they’ve been reading, watching, listening to.

The strategy to build it is a wide and deep topic, with great books and experts to take advice from. Do your research. And repeat (nobody knows you).

5. Extreme competence

Those in the top percentile of knowledge and skill in any discipline win big. Not only will they still be valuable. They concentrate most of the value.

Just from being marginally better, like running a quarter mile a fraction of a second faster, some people get paid a lot more—orders of magnitude more. Leverage magnifies those differences even more. Being at the extreme in your art is very important in the age of leverage. - Naval Ravikant

AI is a spectacular equalizer. It can get anyone from zero to competent in almost anything. It writes good code, produces quality analyses, drafts reasonable strategies. The gap between a beginner and an intermediate practitioner is collapsing fast.

The top cardiologist, the elite software architect, the best trial lawyer — these people don’t just know more. They have pattern recognition built over tens of thousands of hours. They’ve seen the weird edge cases. They know when the textbook answer is wrong. They have built taste.

When everyone has access to “good enough,” the people who are genuinely exceptional become absurdly valuable by contrast. At the very least, they will be sought after to post-train the cutting-edge models in their disciplines and paid handsomely.

In my view, there are two alternative paths in the future that is coming. One is to become an ultra-leveraged generalist. The other is to become an extremely competent specialist.

The holy grail would be the ultra-leveraged specialist. But on the one hand, there may not be enough time for both and living a life. On the other, the differences in brain wiring among people make it rare.

If you go this route, the playbook is simple, but the execution might take decades: go deep, not wide. Pick your domain. Put in the reps that AI can’t shortcut. Read the primary sources, not the summaries. Build the intuition that only comes from doing the actual thing, repeatedly, in messy real-world conditions.

Pick wisely.

6. AI Proficiency

The ultra-leveraged individual knows his AI.

“The goal is not automation; it’s augmentation—with AI as humanity’s most powerful collaborator.” - Eric Schmidt

Much like navigating the web, using spreadsheets and word processors, or managing email, knowing how to effectively use agents and AI tools is becoming a meta-skill.

Easy to use. Harder to master.

AI proficiency is architectural. It’s the ability to look at a problem, decompose it into the parts a human should own and the parts a machine should handle, and then orchestrate both into something neither could produce alone.

It is also maintaining a core toolkit that is updated and upgraded but, at the same time, doesn’t fall for excessive bloat.

I think of it as a new kind of literacy. Not like learning a programming language. More like learning to read.

7. Creativity(?)

The question mark is there not because creativity doesn’t matter. Your specific conception of creativity may not matter much.

AI can generate music, write novels, produce photorealistic images, output riveting visuals and compose marketing copy that converts. If your definition of creativity is “producing novel outputs” or “creating visually striking art,” the frontier models are already there.

However, there is the other creativity. The one that always has a human behind it, making non-obvious choices. Choosing the unexpected angle. Combining two ideas that had no business being in the same sentence. Defending an unpopular point of view. Knowing what to leave out.

That’s taste. And taste might be the real skill hiding inside the word creativity.

Picasso, Leonardo, Zaha Hadid, Pininfarina, Murakami. Yes.

But also, Jason Fried and DHH (with their contrarian approach of running a business and a life). Josh Waitzkin and his approach to learning. Tim Ferriss and his way of interviewing and writing.

AI is a phenomenal tool for execution of creative work. It can iterate faster than any human. Produce more variations. Explore more of the possibility space. But it doesn’t know how to defend a unique point of view. It doesn’t understand that the slightly imperfect version has more soul than the polished one.

How does one develop this kind of creativity? Again, what the heck do I know?

But, to close the circle, creativity may just be a specific type of judgment. The one you develop through your life and apply to your work consistently and uniquely.

Claude Opus 4.6 is already better than most humans at most knowledge work. I am not as intensive a user of the other frontier models but I assume they are too.

This is especially true when packaged in a product like Cowork and Claude Code, and when complemented with skills, plugins, subagents and connectors.

Assuming this statement is true, why is AI not adding trillions of dollars to the global GDP?

Now, the top percentile of professionals is still better than Claude at what they do. But, by definition, most humans are not in the top percentile of their profession.

Also, there will always be an elusive group of activities in which the best models are not yet competent out-of-the-box. For example, those requiring visual taste and design skills or require complementary technologies to advance further (eg. those that have a physical nature and advanced robotics to catch up).

Apart from these, the answer to the question may live in three factors: diffusion, coordination and trace

Diffusion

Dario Amodei, Anthropic’s CEO, hinted in a recent interview at diffusion being the key drag for the AI generation of real and massive enterprise value.

Diffusion, or time-to-diffusion, may be defined in this context as the time it takes for a working tech that would generate obvious productivity gains to be effectively adopted by organizations and institutions.

In other words, while individuals and startups adopt AI tools almost immediately, enterprises lag despite the obvious productivity gains. In his own words, a piece of tech like Claude Code is extremely easy to set up, yet large enterprises adopt it “many months slower”.

Legal reviews, security compliance, procurement, provisioning. These are friction points he cites that persist even with compelling AI products. The “country of geniuses in a data center” wouldn’t instantly transform the economy.

He’s right. I see it every day.

But the drag may be more human than he suggests.

Awareness: Most executives and managers don’t even really know these capabilities exist. Best-case scenario, they might have discussed it in their steercos and board meetings. They may have heard about Codex, Cowork and Langchain from an adept employee or their consultant of choice. But they don’t really know it. They haven’t really seen it work. They haven’t felt it. Even if they say they do, they don’t.

Not too many people have dangerously-skipped-permissions on Claude Code and seen it one-shot a complex feature or an entire web app. Very few have observed how Cowork creates a rather complex financial model with only a decent briefing. Even less have set up a squad of agents on OpenClaw, ever heard about Conductor to orchestrate several agents or know about the existence of companies like Sierra.

The gap between “I’ve heard of AI” and “I’ve seen what it does” is enormous.

This is not an executive problem. It’s a generally human one. The chart below has circulated for a couple of weeks now but still illustrates it beautifully.

If you are not truly aware of the capabilities of something, how are you supposed to make the case for it? Present it, vouch for it, push it forward. This alone may be the single most important factor for the diffusion lag.

Focus: Once you have awareness on the power of AI you still need the bandwidth and time to explore it. To play with it. Test it, mess up and start again.

Even if you have talented and passionate individuals in your organization who may make waves with the tech, they just can’t handle it because they lack the space and focus. Sad yet extremely frequent.

Incentives: Depending on the size, type of activities and dynamics a specific group has, they might just not be incentivized to truly insert AI into their work. Especially if they have the slightest hint of the true capabilities of the best frontier models. Especially around technology teams.

News like the recent Amazon layoffs on their Prime Video and Twitch divisions don’t make the case easier.

“Show me the incentive and I’ll show you the outcome.” - Charlie Munger

Individuals and teams need to feel secure and empowered to be encouraged to adopt and deeply integrate the technology. The mere suspicion they are not, and the organization will have a very hard time making the best of it.

Coordination

Put simply, a job can be thought of as a combination of tasks plus coordination activities. Tasks can be simple or complex, tactical, operational or executive (e.g., making a hiring decision IS a task). They are the core of a professional role.

Coordination are those activities that are done to effectively accomplish tasks, individually or in a collective (e.g., a company). Think meetings, email, standups, watercooler conversations and Slack chats but also status reports, project trackers, project management materials, kanban boards and an innumerable amount of tools.

Humans spend an inordinate amount of time on coordination activities. To the point that it is an industry on its own and entire roles are dedicated exclusively to it (e.g., PMOs, scrum masters, etc.).

Research shows that knowledge workers spend roughly 60% of their time on coordination overhead. Just, crazy. A 60% tax.

According to Asana’s Anatomy of Work Index, 60% of a person’s time at work is spent on work about work and not on skilled work

Although most professionals would much rather invest their time in actual tasks and excessive coordination rituals receive a fair amount of hate, some of it will always be necessary to accomplish worthwhile endeavors involving more than one person.

The deployment of AI tools and agentic workflows within the enterprise adds new coordination layers to the stack while changing current ones entirely:

• Agent to human → How does a customer service voice agent summarize progress and/or escalate interactions effectively? What is the right format and cadence to evaluate effectiveness and accuracy?

• Human to agent → Given an agentic workflow that monitors customer behavior and contextually communicates with him, how does a digital marketing manager track and steer its behavior?

• Agent to agent → How do multi-agent systems hand off tasks among agents? What is the most effective architecture for latency, accuracy and costs? Can it replace entire human coordination pipelines entirely?

This symbiosis between humans and agents is not solved and still requires deliberate thought to do effectively. The chatbot paradigm in AI is so sticky because coordination is organically part of the product.

Agent to agent coordination is an ocean of opportunity. Improving it across different use cases and tech stacks is probably going to mint millionaires around it.

For companies thinking about how to deeply integrate AI in their business processes, coordination is a fundamental question without a standard answer. Human in the loop is no longer the only paradigm to think about. Human parallel to the loop, after the loop or outside the loop might be considered too for specific use cases.

This is just not yet in their mental frameworks.

Traces

In my last post I argued that our ability to encode expertise in language is a bottleneck for AI value creation. That’s true. But it’s not the whole story.

Encoding the skills and procedures is fundamental. Scalable access to data and rules, a must. But to be truly effective, agents need something else: decision traces.

The decision traces – the exceptions, overrides, precedents, and cross-system context that currently live in Slack threads, deal desk conversations, escalation calls, and people’s heads. - Jaya Gupta

(Related to the previous point, many decision traces originate from coordination activities.)

Real-world work is full of ambiguity. That ambiguity is solved by humans through memory of precedents, organizational understanding and synthesis among systems and off-system discussions. But AI agents don’t have access to those traces on a database or system of record.

This connects directly to coordination. Many decision traces originate there — in the meetings, threads, and calls that surround actual work.

Jaya Gupta wrote a brilliant piece about this on X. He calls the structures formed by accumulated traces context graphs. Beautiful. I won’t try to improve on it. Go read the original.

It is so good I don’t see expanding on this point myself worth it. Nor would I do it justice. Go ahead and read the OG.

That’s it for this week.

Next, I’ll dig into what we can actually do about each of these three drags — diffusion, coordination, and trace. One post each.

Nicolas Bustamante recently wrote a piece on vertical SaaS defensibility that blew up on X. It’s worth reading the whole thing. But one passage stuck with me.

Traditional vertical software encodes business logic in code. Thousands of if/then branches, validation rules, compliance checks, approval workflows. Hardcoded by engineers over years... and not just any engineers. You need software engineers who actually understand the domain, which is rare.

LLMs turn all of this into a markdown file.

Read that again. Decades of carefully encoded (and coded!) domain knowledge — the kind that required engineers who actually understood healthcare billing, or freight logistics, or insurance underwriting — collapsed into a text file.

Foundation models are particularly good at reading, understanding, creating and updating markdown files.

Skills - a standard introduced by Anthropic on October ‘25 - use this file format to package specific know-how. At the center of every Skill sits one file: SKILL.md.

A Skill is basically a folder that teaches an agent how to handle a specific task or workflow. Build an Excel model. Prepare a marketing report. Refactor Python code. The folder can hold instructions, domain knowledge, scripts, reference files — whatever is needed to get the job done effectively.

If this weren’t enough, Skills aren’t always loaded. They’re summoned on demand.

Whenever the request description matches the Skill’s capabilities and definition, it gets pulled into the session. When it doesn’t match, it stays out of the way.

This means that an AI tool can draw from hundreds of Skills — general-purpose and custom — without stuffing them all into memory at once. The context window stays clean. The answers stay sharp.

Also, they can be packaged up into Plugins. A combo of Skills, Agents, MCP servers and Hooks (automation triggers that run on events like file save or task completion).

Most people haven’t paid attention to this yet. Skills remain one of the most under-appreciated primitives in the space — even as nearly every major AI platform has quietly adopted the same pattern for packaging capabilities.

If you think about it, a markdown file is just a text file with some formatting. Anyone can read one. Anyone can edit one. Anyone can audit one. You don’t need to be an engineer. That’s the real shift. The person who understands healthcare billing can now write the Skill herself. The freight logistics expert doesn’t need a developer to translate his knowledge into code. Domain expertise goes straight into the file, and the model picks it up from there.

Specialization used to be enshrined in the codebase. Now it lives in documents anyone can edit.

Updating your business logic used to mean a sprint, a backlog ticket, and a deploy. Now it means editing a text file.

However, I think there is something else going on here.

The immediate temptation is to equate these markdown files with a way to encode SOPs (standard operating procedures) and document business workflows. And yes, Skills are that.

But they go further. They don’t just encode what to do. They encode how it should look and feel.

---
name: frontend-design
description: Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.
license: Complete terms in LICENSE.txt
---
<< SKIPPED FOR CONCISIVENESS >>

## Frontend Aesthetics Guidelines

Focus on:
- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font.
- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
- **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise.
- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays.

NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts and component patterns, and cookie-cutter design that lacks context-specific character.

Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices (Space Grotesk, for example) across generations.

**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well.

Remember: Claude is capable of extraordinary creative work. Don't hold back, show what can truly be created when thinking outside the box and committing fully to a distinctive vision.

Source: https://github.com/anthropics/claude-code/blob/main/plugins/frontend-design/skills/frontend-design/SKILL.md?plain=1

The example above is part of a Claude Skill, developed by Anthropic themselves, that teaches the model how to properly design frontend digital interfaces. Not just “put a button here” — the visual principles, the stylistic cues, the design sensibility behind the decisions. They’ve built others that teach the model how to create a PowerPoint, build a financial model, or write a Product Requirement Document.

If you read the markdown again you’ll notice that it isn’t a checklist. It’s trying to transfer taste.

So, is it markdown, maybe in combination with other techniques, the ultimate mechanism by which we can encode what looks good? What feels right? What separates competent from elegant?

I think it is. Not perfectly. Not always. But more than most people realize.

It only really works if you can explain the thing. If you can describe it clearly enough — the principles, the patterns, the reasoning behind the choices — the model can pick it up and apply it consistently.

The hard part isn’t the AI. It’s us. It’s our ability to encode in language the why and how.

Professional intuition. Artistic judgment. The feeling that a layout is “off” without knowing why. The sense that a strategy will work without listing the reasons.

Try writing that down in a markdown file. Most experts can’t articulate what they know — they just do it. That’s always been true. Long before AI entered the picture.

So the bottleneck isn’t whether the model can read and apply taste and judgment. It’s whether we can explain ours.

One cannot help but wonder how far the combination of Skills, JSON, reference documents, scripts, subagents and tools can get us in encoding human judgment and taste.

But most likely, it is our own limitation in describing the most nuanced aspects of what we do that will set the limits of the possible — not the AI capabilities.

For the foreseeable future, at least until the labs heap AGI upon us, the generation of real economic value by AI in the enterprise will be coming from the deployment of custom agentic systems to automate, create or augment concrete business processes.

Most professionals today interact with AI through general-purpose interfaces—ChatGPT Enterprise, Claude, Microsoft Copilot, or on-prem models with a UI on top. These tools are impressive individual productivity enhancers. Top coding agents write production code. Agentic interfaces like Claude Cowork run autonomously and produce increasingly decent business outputs. But they face three structural challenges with no clear solution in sight.

1. Their effectiveness depends on the willingness, proficiency and consistency of the individuals using them.

2. The jagged frontier. Building a tool or system that is actually effective at everything is so far impossible. Current foundation models work surprisingly well at some tasks while failing unexpectedly at others that may seem similar or even simpler, making it difficult to intuitively predict where AI will help versus hinder performance.

3. Even if used effectively, the productivity gains and economic value generated with them is extremely difficult to measure and attribute to specific business processes.

On the other hand, the deep integration of AI capabilities through agentic systems in business workflows does have the potential to transform them from the ground-up.

However, with hundreds to thousands of processes to potentially rethink, where to start and which to prioritize is a tricky question without a cookie-cutter answer.

Based on our direct experience and research, a set of key characteristics provide early indicators that a specific process will accrue higher value from its redesign as agentic. Here is the TOP 10:

1. Heterogeneous inputs and arbitrary documentation formats Processes requiring interpretation of unstructured documents—contracts, correspondence, images, mixed-format files—exploit LLM multimodal capabilities that traditional automation cannot match.

2. Multi-system integration and data aggregation needs Workflows spanning three or more systems with data synthesis requirements benefit from agents’ orchestration capabilities.

3. Complex rule-based logic with frequent exceptions Processes with branching decision trees, exception handling, and conditional logic streams are ideal.

4. High volume, repetitive task patterns Transaction volume provides the denominator for ROI calculations. Some industry frameworks cite minimum 2 FTE equivalent workload as the viability threshold.

5. Sequential dependencies where step completion accelerates subsequent steps Workflows with “waterfall” characteristics—where output from step N becomes input for step N+1—benefit from agents’ ability to maintain context and build upon prior work.

6. Back-and-forth communication with multiple stakeholders Processes requiring iterative exchanges both internally and/or externally —clarifications, approvals, information gathering across parties—exploit agents’ conversational capabilities with near-zero latency interaction.

7. Parallelization potential Workflows with independent subtasks that can execute simultaneously maximize agent efficiency.

8. Tolerance for gradual autonomy Workflows where incremental automation delivers incremental value—versus all-or-nothing requirements—enable the recommended phased approach.

9. Existing SOPs and process documentation Well-documented processes with clear standard operating procedures provide the ground for agent development and codification.

10. Clear, verifiable success metrics: Processes with objective success criteria (accuracy rates, processing times, compliance scores, unit tests..) allow agents to self-evaluate and improve. This is one of the main reasons why coding agents are the most evolved and arguably autonomous AI systems. Code compiles, runs and goes through unit tests.

At Visa Consulting, our AI Labs practice helps financial institutions, fintechs, and merchants identify, architect, and deploy agentic systems that deliver measurable business value in payments, consumer finance, and commerce.

If your organization is navigating where to start with agentic AI — or how to move from pilots to production — reach out.