← Articles

What Does a Full-Stack AI Agent Look Like? Reasoning, Discovery, and Execution

Published July 29, 2026Updated July 29, 2026Thesis

Key takeaways

  • A full-stack AI agent has three layers: reasoning, discovery, and execution. Most agent products have the first two and stop before the third.
  • Execution is four problems: sign-in at merchants, payment credentials the agent can use safely, checkout to completion, and management of the order afterward.
  • Each of the four problems is deep, defended by merchants, and subject to compliance rules, such as PCI DSS for card data.
  • Execution is undifferentiated and permanent work, so it tends to become shared infrastructure, as hosting, authentication, and payment processing did.
  • For the user, execution should show as one approval of specific terms and then a completed order.

A full-stack AI agent reasons about what the user wants, discovers the right option in the real world, and executes the transaction. The third layer, execution, is the one most agents do not have. Execution covers sign-in at merchants, payment credentials, checkout, and the management of the order after the purchase.

This essay explains why execution is the hard layer and why it tends to belong in shared infrastructure rather than in each agent product.

What is the half-agent problem?

The half-agent problem is that many AI agents stop one step before the result the user wanted: they recommend, and the user must complete the purchase. A shopping agent returns three jackets and a link. A food agent picks a restaurant and shows a menu. A travel agent builds a five-day itinerary and asks the user to book it.

The final handoff is where the value leaks out. The user came with a task, and the agent returned more work. The handoff also makes the agent easy to replace, because a recommendation competes with every search box.

Half-agents are the expected result of the current stack. Teams can buy reasoning as a model, but they cannot easily buy execution, so they build what is available and stop there.

An agent that recommends competes with search. An agent that completes the task replaces the errand.

What layers does a full-stack AI agent contain?

A full-stack AI agent contains three layers: reasoning, discovery, and execution. Each layer does different work, and skill at the first two does not imply skill at the third.

  • Reasoning: Understand an underspecified request, apply the user's constraints and history, and decide what should happen. Foundation models do this well, and it is now expected.
  • Discovery: Ground the decision in what is available now: real inventory, real prices, real delivery windows. This is data and integration work, and many teams do it well.
  • Execution: Make the transaction happen: sign in, pay, check out, and handle what comes after. This layer turns an assistant into an agent, and it is where products stall.

The layers do not improve in the same way. Reasoning improves when a better model ships. Discovery yields to engineering effort. Execution does neither, because it combines a technical problem with security, fraud prevention, and financial regulation.

What problems make up agent execution?

Agent execution is made up of four problems: authentication at merchants, payment credentials, checkout completion, and ongoing interaction after the order. When a team says it needs to add checkout, it usually means all four.

Authentication: sign-in at merchants

Much of commerce sits behind a login. Accurate prices, saved addresses, delivery windows, loyalty prices, and order history depend on the session, so an agent that cannot sign in cannot see the correct order. Sign-in often needs a one-time passcode sent to the user, so it is more than a credentials problem.

Payments: credentials the agent can use safely

An agent needs a real payment method and should not hold a raw card number. PCI DSS applies to every system that stores, processes, or transmits card data, so a team that handles card numbers takes on a compliance program. The common alternative, a request that users enter a card at each merchant, removes the convenience that made the agent useful.

Checkout: complete the purchase

Checkout has many stateful steps: cart, fulfillment choice, address validation, taxes, tips, and confirmation. Bot detection and CAPTCHAs defend these steps against unidentified automation. Each merchant builds its checkout differently, and each one changes without notice.

Ongoing interaction: what happens after the order

The transaction does not end the agent's contact with the merchant. Orders change, arrive late, get substitutions, or get cancelled and refunded. Reservations move, and bookings need changes. An agent that can buy but cannot manage what it bought gives the user a new problem.

Execution problemWhat makes it hardWhat it costs a team that builds it
Authentication at merchantsSession-dependent data and one-time codes sent to the userPer-merchant maintenance with no end
Payment credentialsCard data must not reach the agentPCI scope, a vault, and card network requirements
Checkout completionStateful multi-step flows behind bot detectionContinuous work for each merchant category
Ongoing interactionChanges, cancellations, refunds, and disputesOperational and support load that grows with volume

Read the table as a build-or-buy argument. One row is a large engineering project. All four rows, maintained across a growing set of merchants, is the work of a payments and infrastructure company, which is not the company most agent teams set out to build.

Why do agent teams rarely build execution in-house?

Agent teams rarely build execution in-house because the work is undifferentiated and permanent. Users do not choose an agent because its team wrote its own card vault. They choose an agent because it understands them and completes the task.

  • It is defended territory: Merchant defenses exist to stop unidentified automation. The durable answer is a verifiable agent identity, for example with Web Bot Auth or card network agent programs, not more workarounds.
  • It carries compliance obligations: Card data brings PCI DSS obligations and audits. That cost does not fall with clever engineering.
  • It has no finish line: Merchants change their checkouts, networks update their agent requirements, and fraud systems retune their models. Shared across many agents, this maintenance costs each one less.

The same logic made hosting, authentication, and payment processing into infrastructure categories. Every product needs them, none of them set a product apart, and each is cheaper to use than to rebuild. Agent execution follows the same pattern.

What does a full-stack agent look like in each category?

In each category, a full-stack agent completes the transaction that a recommendation-only agent hands back to the user. The execution layer is the same in every category.

  1. 1

    Shopping agents: Today the agent returns options and outbound links. With execution, the agent buys the item under terms the user approved, and the receipt and follow-up stay in the product.

  2. 2

    Concierge agents: Today the agent suggests dinner, groceries, or a gift. With execution, the errand is done, which is how users judge a concierge.

  3. 3

    Travel agents: Today the agent builds an itinerary and sends the user to booking sites where prices have already moved. With execution, the agent books the trip and handles changes later.

  4. 4

    Search agents: Today the agent gives a better answer, earned through referral fees if at all. With execution, the answer ends in a transaction.

In each category the reasoning was already good enough, and the missing capability was the same. When four product categories are blocked by one layer, that layer fits best as a shared dependency.

How should work divide between an agent builder and an execution layer?

An agent builder should own everything the user sees, and an execution layer should own the parts that are defended and regulated. This split lets the builder focus on the product without taking on payments compliance.

Agent builder ownsExecution layer owns
The reasoning, taste, and personality of the agentVerifiable agent identity and card network registration
The interface, including the approval momentPayment credentials, tokenized in a PCI DSS compliant vault
The relationship with usersCheckout execution at the merchant
The choice of categories and merchantsMerchant coverage and its maintenance
The business modelThe compliance surface for card data

What does the end user experience?

The end user experiences one approval of specific terms and then a completed order. The complexity above should not be visible. The approval pattern resembles a payment sheet such as Apple Pay, because people already trust that pattern with their money.

  1. 1

    The user asks for something: A normal request in normal language, inside the agent's product, with no handoff to another site.

  2. 2

    The request becomes an intent: The system turns the request into a structured, line-item record of merchant, items, and amounts. The user sees the exact purchase before it happens.

  3. 3

    The user approves it in the product: A scoped approval appears in the agent's own interface and the user confirms it with a passkey or biometric.

  4. 4

    The purchase runs within those terms: The checkout runs at the merchant with the user's tokenized card. The agent never sees the card number and cannot buy outside the approved terms.

  5. 5

    The user keeps normal protections: The charge runs on the user's own card, so the user can dispute it through their bank as with any other card purchase.

For the user, that is all of the execution layer: one approval, then a completed order. Everything else is infrastructure that works out of sight.

What is the full-stack agent thesis?

The full-stack agent thesis is that an agent is complete only when reasoning and discovery connect to an execution layer that completes transactions. The web was built for people who hold cards and type into forms. Until shared infrastructure fills that gap, each agent product meets the same obstacle in the same place.

A full-stack agent is not a bigger model or a longer context window. It is reasoning and discovery attached to execution, with the user in control of each purchase and the builder in control of the experience.

Frequently asked questions

What does "full-stack AI agent" mean?

A full-stack AI agent reasons about what the user wants, discovers the real-world option, and executes the transaction. Most agents cover only reasoning and discovery and return a recommendation. Execution adds sign-in at merchants, payment credentials, checkout, and order management after the purchase.

Why do agent teams avoid building the execution layer themselves?

Agent teams often avoid building the execution layer because the work is undifferentiated and permanent. Card handling brings PCI DSS scope, merchant checkouts change often, and bot detection stops unidentified automation. None of this sets one agent apart from another.

What does execution include beyond taking a payment?

Execution includes four things beyond payment: sign-in at merchants where real prices and delivery options live, credentials the agent can use without seeing a card number, multi-step checkout to a confirmed order, and management of changes, cancellations, and refunds afterward.

Does an agent builder lose control of the user experience with an execution layer?

An agent builder does not have to lose control of the user experience. In a well-designed split, the builder owns the reasoning, the interface, and the approval moment, and the execution layer works behind it with no redirect to another brand.

How does the user stay in control of what the agent buys?

The user stays in control by approving a structured, line-item record of merchant, items, and amounts before the purchase. The system enforces those terms during execution, so the agent cannot buy outside them.

Which kinds of agents need an execution layer?

Shopping, concierge, travel, and search agents all need an execution layer. Each one currently returns a link, a suggestion, an itinerary, or an answer, and each is blocked by the same missing capability to complete the transaction.

Related articles