Agentic commerce interview: Studio Science CTO Aaron Hutten

Agentic commerce interview: Studio Science CTO Aaron Hutten

Agentic commerce interview: an agent that issues a refund is not a chatbot

An agent recommending a product is a conversation. An agent modifying an order, reserving inventory or issuing a refund is a transaction — with concurrency, idempotency and recovery requirements that commerce has spent decades solving and that a non-deterministic decision layer does not inherit. In this agentic commerce interview, Studio Science’s Aaron Hutten explains what has to be rebuilt.

Studio Science is a technology consultancy, and Aaron Hutten is its CTO. The firm works with enterprise commerce platforms, integrations and large-scale transformations, and is currently working on agentic commerce architectures — how AI agents interact with enterprise commerce APIs and transactional services.

Studio Science

Its relevance to this agentic commerce interview is that consultancy work exposes the gap between a demonstration and a deployment. A shopping agent that works in a demo and one that can safely touch pricing, inventory, payment authorisation and order management are separated by everything the brief describes.

Aaron Hutten

Aaron Hutten is the CTO of Studio Science, with more than two decades building enterprise commerce systems — Salesforce Commerce Cloud, order management, payments and customer-facing platforms — and leading large-scale technology transformations.

His argument in this agentic commerce interview is that the industry conversation is still stuck on model capability, reasoning and orchestration, while the harder engineering problems sit elsewhere. Specifically: agents need to be treated as transactional systems rather than conversational interfaces. Recommending a product is one thing; modifying an order, issuing a refund, reserving inventory or initiating a payment is something else, and it inherits decades of work on concurrency, idempotency, transaction integrity and failure recovery that a non-deterministic decision layer does not automatically satisfy.

He argues the biggest obstacle to enterprise AI is not the model but the systems it must interact with — legacy platforms, undocumented business logic, fragmented customer data and integrations built over fifteen or twenty years. And he is experimenting directly: he has been building enterprise storefront capabilities with AI generating much of the implementation, which has moved the bottleneck from writing code to validating integrations, designing data models and testing failure scenarios.

—

Transactional, not conversational

Q1. In one sentence: what changes when an agent issues a refund rather than recommends a product?

AH: Pretty significant difference. One is making a recommendation, the other is moving money. Now we’re dealing with authorization, financial exposure, and transaction integrity.

Q2. Of the old problems — concurrency, idempotency, transaction integrity, recovery — which does a non-deterministic decision layer actually make worse, and which does it leave untouched?

AH: None of these problems are new. We’ve been dealing with concurrency and transaction integrity in commerce for decades. Agents just introduce less predictable execution paths, which makes idempotency and recovery more complicated. The underlying platform requirements haven’t changed.

The transaction boundary

Q3. You ask how to architect the environment so an agent can act without a human supervising every step. Where does the transaction boundary sit, and what owns it — the agent, a service layer, or the platform?

AH: The platform. The agent decides what it wants to do, the service layer validates whether it can, and the platform executes it. I don’t want an LLM interpreting refund policies or managing transaction state. That’s what the existing systems are for.

Q4. What is the hardest failure to recover from when an agent is mid-transaction and something breaks — and what does recovery look like?

AH: Probably an ambiguous transaction. A refund processes, the response times out, and the agent tries again. Now we’ve potentially refunded someone twice. You need idempotency, transaction state, and reconciliation with the payment provider. The agent shouldn’t be guessing what happened.

Legacy reality

Q5. “A better model doesn’t resolve those dependencies. Architecture does.” Name the top three dependencies that block agentic commerce in a real enterprise.

AH: Disconnected enterprise systems, inconsistent business logic across APIs, and poor visibility into transaction state. Most enterprises are still trying to get commerce, OMS, ERP, and payments to agree on what happened. A better LLM isn’t solving that.

Q6. Is there a class of enterprise where agentic commerce is simply not feasible yet, and how would you tell?

AH: Absolutely. If you can’t reliably execute and recover a transaction through your existing APIs, you probably shouldn’t introduce autonomous agents. I’d start there before spending a bunch of money on AI.

The AI-built storefront

Q7. You built storefront capabilities with AI generating much of the implementation. What did the models do well, and where did they reliably fail?

AH: It was surprisingly good at generating components, integrations, and application code. Where it fell apart was platform-specific behavior. It would make assumptions about Salesforce Commerce APIs or miss dependencies between catalog, inventory, and pricing. The JavaScript was rarely the problem.

Q8. What did that exercise teach you about platform constraints that you could not have learned by reading the documentation?

AH: The documentation explains what individual APIs do. It doesn’t always explain what happens when you start connecting everything. Working across OCAPI, SCAPI, WebDAV, and Managed Runtime exposed dependencies and sequencing issues you really only discover by building against the platform.

Discipline at volume

Q9. If code generation becomes cheap, how do you maintain engineering discipline as the volume of software rises? What has actually worked, and what has not?

AH: You spend more time validating and less time writing. Smaller changes, clear constraints, automated tests, and testing against the actual platform worked well. Giving the model a massive objective and hoping it maintained consistency didn’t. Turns out AI is pretty good at generating technical debt, too.

Putting to the test

Q10. What would prove you wrong — is there a commerce case where an agent should never transact, regardless of how good the model gets?

AH: I don’t think there’s a blanket answer. Some transactions absolutely require human authorization, whether that’s regulatory or financial risk. But we already trust software to execute significant financial transactions. The question is whether the agent operates within the same controls, not whether it’s an agent.

Q11. A CTO about to let an agent touch orders or payments: what should they build first?

AH: Start with one narrowly defined transaction and the service layer around it. Authorization, business rules, idempotency, logging, recovery. Prove you can handle failures before expanding what the agent can do. I’d prioritize that over spending another six months evaluating models.

Q12. What is the strongest argument against the transactional framing — that it is over-engineering, and supervised agents with a human approving each step are fine?

AH: For some use cases, sure. Human approval is completely reasonable. But approving a transaction doesn’t mean it executes correctly. You can still have duplicate payments, failed integrations, and inconsistent order states. Human approval solves an authorization problem, not a transaction integrity problem.


Agentic commerce interview: Studio Science CTO Aaron Hutten

TechRecast Analysis (The Recast)

The Shift in Context — Agentic commerce is being demonstrated as an experience: a conversation that ends in a basket. The engineering question is what happens when that conversation ends in a transaction that must be exactly-once, recoverable and reversible. Commerce solved those problems under human-initiated load; agents change the initiator, not the requirements. That is where this agentic commerce interview sits.

Why This Interview Matters — Most agentic AI coverage is about capability and orchestration. This is about the properties a system must have before an agent can be trusted with money — and the observation that a non-deterministic decision layer does not inherit any of them for free is the kind of point that changes an architecture review rather than a slide.

Technology Perspective — The technical crux is that an agent is a decision layer wrapped around a transaction, and the transaction’s guarantees cannot be delegated to the model. Idempotency has to be enforced below the agent, so a retry does not double-charge; recovery has to be designed for the state where the agent’s intent is known but the outcome is not. The hardest case is the ambiguous one — the payment call that times out — because the agent cannot resolve it by reasoning and the platform must.

Business and Market Perspective — The commercial logic is that the gap between a demo and a deployment is where consulting value lives. A retailer can buy an agent that recommends; it cannot buy one that refunds until the underlying systems expose safe, idempotent operations and the failure paths are designed. That makes integration work the real cost, which is unglamorous and accurate.

Leadership Perspective

A CTO with two decades in commerce platforms is reasoning from systems that already handle money at scale, which is a more demanding baseline than most AI teams have. The relevant lens is whether that produces rigour or scepticism that underrates what models can now do.

The Counterpoint — A fair sceptic would argue that the transactional framing is correct but unsurprising — payment systems have always required this, and putting an agent in front of them changes the caller, not the architecture; that supervised agents with human approval are a perfectly good answer for most retailers; and that the AI-built storefront is an anecdote rather than evidence. On this view, the argument is sound engineering and not a new insight. This is the strongest opposing case and deserves a direct answer.

What Comes Next — Watch three signals: whether commerce platforms publish idempotent, agent-safe APIs as a product feature, whether “agent-safe transaction” becomes a named pattern in integration documentation, and whether failure-recovery design becomes a standard part of agentic commerce projects.

Industry Outlook — If Hutten is right, agentic commerce advances at the pace of integration work rather than model improvement, and the winners are the consultancies and platforms that solve the plumbing. If he is wrong, supervised agents are good enough and the transactional architecture stays a specialist concern.

Key Takeaways

1. An agent that modifies orders, reserves inventory or issues refunds is a transactional system, not a conversational interface.

2. Concurrency, idempotency, transaction integrity and recovery are inherited requirements that a non-deterministic decision layer does not satisfy for free.

3. The hardest failure is the ambiguous one — the call that times out — because the agent cannot resolve it by reasoning.

4. The biggest obstacle to enterprise AI is the systems it must interact with, not the model; a better model does not resolve legacy dependencies.

5. There is a real gap between demonstrating an AI shopping experience and connecting it to pricing, inventory, payment authorisation, fraud controls and order management.

6. The strongest counter-argument is that this is sound, unsurprising payment engineering, and supervised agents are sufficient for most retailers.