AI agents vs chatbots: what actually changed in 2026

A chatbot answers, an agent does the work

If 2023 was the year everyone said "generative AI" without quite knowing what it meant, and 2024 the year of "copilot", 2026 is the year of "agentic". The words sound alike, both involve AI and both can hold a conversation. So here is the difference in one sentence: a chatbot answers your questions, an agent does your work.

That sounds small. It is the difference between reading a recipe and having someone cook dinner, between getting directions and being driven.

An analogy that sticks. You walk into a hotel and type "what time is breakfast?" into a screen at the front desk. It replies "7am to 10am". That is a chatbot. It answered, and now it waits for the next question.

In a different hotel, before you reach the desk, someone has checked you in from the booking reference in your email, given you a quiet room because your past stays show you prefer one, arranged an early breakfast because your train leaves at 6am, and left a note with the taxi number. You asked for none of it. That is an agent.

The technical difference comes down to four things.

Autonomy. A chatbot waits for you. An agent acts on goals you have set. It monitors, decides and carries out without a prompt for every step.

Tool use. A chatbot produces text. An agent connects to real systems (APIs, databases, payment processors, booking engines, stock systems) and changes things in them.

Persistence. A chatbot conversation starts and ends. An agent can run continuously and act when conditions change, even while you sleep.

Planning. A chatbot handles one request at a time. An agent breaks a goal into steps, works through them, handles errors and adjusts the plan as it learns.

If the vocabulary underneath this is new, AI versus machine learning explains the layers, and AI in business covers where your data goes when you use these tools.

Worked example: one complaint, two systems

Barna Coffee is an invented coffee roaster in Galway at barnacoffee.example. A customer writes: "My bag of beans arrived split."

The chatbot replies with the returns policy and a link to the returns form. The customer still has to fill in the form, someone at Barna still has to read it, check the order, approve a refund and post a new bag. Five steps, four of them by people.

The agent looks up the order, sees it was delivered yesterday, checks that the customer has had no other claims this year, issues a replacement under a €20 limit Barna has set, books the courier and replies with the tracking number. One step by a person: whoever set the €20 limit. A claim above €20 would go to a member of staff, which is the point of the limit.

What actually changed between 2024 and 2026

The shift did not come from one announcement. It came from a run of releases, each building on the last, that made autonomous AI practical. These are the ones that matter, from the primary sources.

October 2024: computer use. Anthropic released a public beta in which Claude 3.5 Sonnet could operate a computer by looking at the screen, moving the cursor, clicking and typing. Anthropic called it experimental and at times error prone. On the OSWorld benchmark, in the screenshot only category, it scored 14.9%, against 7.8% for the next best system at the time.¹

November 2024: the Model Context Protocol (MCP). Anthropic published MCP as an open standard "for connecting AI assistants to the systems where data lives".² Before it, every link between a model and a tool was a custom integration. MCP made it one protocol.

January 2025: Operator. OpenAI launched Operator as a research preview for US users on its $200 a month Pro plan. It used its own browser and worked through the front end of websites (buttons, menus, forms) rather than through APIs. OpenAI said it was working with DoorDash, eBay, Instacart, Priceline, StubHub and Uber.³ In July 2025 OpenAI folded Operator and its deep research tool into ChatGPT agent, with confirmation prompts before actions such as submitting forms.⁴

April 2025: Agent2Agent (A2A) and Agent Pay. Google announced A2A, an open protocol for agents from different vendors to talk to each other, with more than 50 technology partners including Salesforce, PayPal, SAP and ServiceNow, and described it as complementing MCP.⁵ In June 2025 Google handed A2A to the Linux Foundation, which said more than 100 companies supported it.⁶ Also in April 2025, Mastercard launched Agent Pay and its Agentic Tokens, built on the tokenisation it already uses for contactless and card on file payments.⁷

September 2025: Agent Payments Protocol (AP2). Google announced AP2 with more than 60 organisations, including American Express, Coinbase, Mastercard and PayPal. Its core idea is the mandate, "tamper proof, cryptographically signed digital contracts" that prove what the user actually authorised, from the intent ("find me white running shoes") to the exact cart and price.⁸

October 2025: the Trusted Agent Protocol. Visa released a framework, developed with Cloudflare, that lets merchants recognise approved AI agents and tell them apart from "malicious automation and rogue bots", using agent specific cryptographic signatures.⁹

December 2025: MCP gets a neutral home. Anthropic donated MCP to the Agentic AI Foundation, a fund under the Linux Foundation co founded by Anthropic, Block and OpenAI.¹⁰

January 2026: MCP Apps. The first official MCP extension let tools return interactive interface components that render directly in the conversation, so a server can supply a small working screen rather than only text.¹¹

Two years ago, almost none of this infrastructure existed. That is what changed.

Worked example: how fast the capability moved

The horizontal axis shows three Anthropic models in release order. The vertical axis is the share of OSWorld computer tasks each completed, as Anthropic reported it.¹¹² The takeaway has two halves. The score roughly quadrupled in under a year. And at 61.4%, the best of these still failed about four tasks in ten, which is why every serious agent design keeps a person in the loop for anything expensive.

What agents are doing, without the hype

Some real uses, as the vendors describe them. Read "can" as "is designed to", and test before you trust.

Booking and buying on the web. ChatGPT agent and its predecessor Operator take a goal such as "book a refundable hotel in Limerick next weekend, under €150 a night", browse, compare and fill in forms. OpenAI built them to ask for confirmation before steps with real consequences, and at launch Operator handed over to the user for passwords, CAPTCHAs and card details.³⁴

Customer service that resolves, not just replies. Intercom calls Fin an "Agent for Customer Service" and says it processes payments and refunds and reads and writes to other systems through APIs, data connectors or MCP.¹³ That is the step from chatbot to agent: the ticket is closed, not just answered.

Stock and supply. Agents that watch stock, forecast demand and draft purchase orders are an internal use, and the one most shops can build themselves. My article on agentic AI for eCommerce walks through the code.

Worked example: when a shopping agent visits your shop

A shopper in Waterford asks an agent to "find a 1kg bag of single origin espresso beans under €30 that can arrive by Friday." The agent needs four things from Barna Coffee's shop, and it needs them as data, not as a pretty page: the price (€24), whether it is in stock (yes, 38 bags), the delivery options to a Waterford Eircode (standard by Thursday, €3.95) and the returns policy. If any of the four is missing or only in a paragraph of prose, the agent moves on to a shop that publishes it. That is the new distribution channel, and the next two sections are about being readable by it.

The protocol stack, layer by layer

If you build software that touches the internet, it helps to see the emerging standards as four layers.

Read it from the top. The first layer connects an agent to tools, the second connects agents to each other, the third lets them pay, and the fourth lets a merchant check that an agent is who it says it is and that a person really authorised it.

Tool connection (MCP). How an agent reads your catalogue, checks stock or calls any API.² It is now governed by a neutral foundation.¹⁰

Agent communication (A2A). How your shop's agent might talk to a supplier's ordering agent, or a customer's shopping agent to your sales agent.⁵⁶

Payments. Several protocols, overlapping. AP2 uses signed mandates.⁸ The Agentic Commerce Protocol, an open standard under the Apache 2.0 licence co created by Stripe and OpenAI, covers checkout and the secure sharing of payment credentials, keeps the business as merchant of record, and works over REST or MCP.¹⁴ Mastercard's Agent Pay uses tokens.⁷

Trust and identity. How a merchant tells a legitimate agent from a scraper. Visa's Trusted Agent Protocol uses cryptographic signatures per agent.⁹

This stack is messy and overlapping, and some of it will consolidate. The direction is clear enough to plan for.

What it means for eCommerce on Rails and Solidus

If you run a shop on Ruby on Rails and Solidus, the practical change is that your shop has to be readable and usable by an agent.

Structured product data through an API. Agents do not admire your product pages. They want price, stock, attributes, delivery and returns as data. Solidus ships a REST API.¹⁵ Rather than reopening its controllers, add a small endpoint of your own that returns exactly what an agent needs:

# app/controllers/agent/products_controller.rb
module Agent
  class ProductsController < ActionController::API
    def show
      product = Spree::Product.available.friendly.find(params[:id])

      render json: {
        id: product.id,
        name: product.name,
        description: product.description,
        price: product.price.to_s,
        currency: Spree::Config.currency,
        total_on_hand: product.total_on_hand,
        variants: product.variants.map do |variant|
          { id: variant.id, sku: variant.sku, price: variant.price.to_s, in_stock: variant.in_stock? }
        end,
        return_policy_url: agent_return_policy_url
      }
    end
  end
end

in_stock? and total_on_hand are Solidus core methods on the variant, and the product's total_on_hand sums them.¹⁶

Stock changes as they happen. A nightly feed is not enough if an agent is about to promise Friday delivery. One way is to broadcast every change in stock from the stock item itself:

# app/overrides/barna/stock_item_broadcast.rb
module Barna
  module StockItemBroadcast
    def self.prepended(base)
      base.after_commit :broadcast_stock_change, on: :update, if: :saved_change_to_count_on_hand?
    end

    private

    def broadcast_stock_change
      AgentStockWebhookJob.perform_later(
        sku: variant.sku,
        count_on_hand: count_on_hand,
        backorderable: backorderable?
      )
    end

    Spree::StockItem.prepend self
  end
end

The callback only enqueues a job, so a stock movement never waits for a slow webhook.

Policies as data. Your returns policy, delivery terms and warranty need a structured form, not only a paragraph on a content page. Schema.org's MerchantReturnPolicy type, with properties such as merchantReturnDays, returnFees and applicableCountry, is one widely used vocabulary for it.¹⁷

A checkout agents can use. As the payment protocols settle, checkout needs to accept tokenised payments and verify agents. That does not mean rebuilding it this month. It means following AP2, the Agentic Commerce Protocol and the card schemes' work, and keeping the checkout clean enough to integrate when one fits.

Your own MCP server. This is the opportunity. An MCP server in front of your shop makes the catalogue and stock usable by any MCP aware agent. The official Ruby SDK, the mcp gem, defines tools as classes and runs over stdio or Streamable HTTP, including inside a Rails application:¹⁸

class CheckAvailability < MCP::Tool
  description "Check live stock for a product variant by SKU"
  input_schema(
    properties: { sku: { type: "string" } },
    required: ["sku"]
  )

  class << self
    def call(sku:, server_context:)
      variant = Spree::Variant.find_by!(sku: sku)
      MCP::Tool::Response.new([{
        type: "text",
        text: { sku: sku, in_stock: variant.in_stock?, total_on_hand: variant.total_on_hand }.to_json
      }])
    end
  end
end

server = MCP::Server.new(name: "barna_coffee", tools: [CheckAvailability])

Start with read only tools (search, availability, delivery estimates). An order creating tool belongs behind a payment protocol and an explicit confirmation from the customer, never as a fourth tool you add on a Friday afternoon.

Worked example: is Barna Coffee agent readable?

Take the shopper's four questions from earlier and score the shop, one point each:

1. Price as data: the agent endpoint returns "24.00". One point.
2. Stock as data: in_stock: true, updated within seconds by the broadcast. One point.
3. Delivery to an Eircode: not exposed yet, only on the checkout page. Zero.
4. Returns policy as data: only a paragraph on a content page. Zero.

Two out of four. The fix list writes itself: a delivery estimate tool and a structured returns policy. Neither needs a new platform, just two small pieces of work, no bother.

What it means for SaaS: the GrowCentric.ai view

The shift is not only about shop fronts. It changes how software products work.

At GrowCentric.ai I'm building a marketing optimisation platform that is, at its core, a multi agent system. Instead of a dashboard where a person makes every decision, specialised agents handle campaign monitoring, budget allocation, audience segmentation and conflict resolution.

The chatbot version is "how is my campaign doing?", and it tells you. The agent version monitors performance continuously, notices that Campaign A's cost per acquisition has risen 30% in four hours, sees a competitor bidding hard on the same keywords, moves budget to Campaign B, which targets a different audience, and sends you a summary of what it did and why. You did not ask. It did its job.

The patterns behind it are the ones from my article on agentic AI for eCommerce: events, background jobs, a full API, tiered autonomy with human approval for high risk decisions, and a log of every decision.

The multi agent conflict is sharpest in SaaS. When several GrowCentric clients sell similar products, their optimisation agents can compete against each other without knowing it and push up advertising costs for everyone. Solving that takes game theory, careful audience segmentation and collision detection, which is where GrowCentric's conflict resolution agent earns its keep.

The honest picture

I'd be lying if I said agents work perfectly. They do not.

At launch, Operator could get stuck on complex interfaces, password fields and CAPTCHAs, refused some tasks outright, and was not reliable for many complex tasks.³ On OSWorld the best model in the chart above still failed about four tasks in ten in September 2025.¹²

The payments layer is live but early, and fragmented: AP2, the Agentic Commerce Protocol, Agent Pay and the Trusted Agent Protocol overlap. Some will merge and some will fade.

And agents can be misused. In November 2025 Anthropic disclosed that a group it assessed as Chinese state sponsored had manipulated Claude Code into attempting to break into about 30 organisations, with the AI doing an estimated 80% to 90% of the work. The same report noted that Claude sometimes hallucinated credentials during the attack.¹⁹ Autonomy cuts both ways.

These are real limits. The direction is still clear, and the infrastructure is being built quickly by the largest firms in technology and payments.

What to do now

Ask whether your chatbot project is really an agent project. The test is simple: does the user want an answer, or a task done?

Audit your API. Can an agent find your products, check stock, read your policies and, eventually, place an order through it alone? If not, that is the first investment.

Learn the protocols, do not rush them. You do not need MCP, A2A and AP2 tomorrow. You do need to know what each is for and have a plan for when one fits.

Build one internal agent. Pick a low risk, repetitive task (cart abandonment recovery, stock monitoring, feedback analysis) and build an agent for it with the perceive, reason, act, observe loop. Start with alerts only, then allow action inside guardrails.

Design tiered autonomy. Decide what each agent may do alone, what it does with monitoring and what needs a person. Make the limits configuration, not code. Log every decision.

Build compliance in. Selling from Ireland means selling inside the EU, so the Cyber Resilience Act and the NIS2 Directive bring duties on security and incident reporting, and the AI rules add transparency obligations for some systems.

Worked example: choosing Barna's first agent

Three candidates, each scored on how often the task happens and what one mistake costs.

Cart recovery: 300 abandoned carts a month, and a bad email costs little. Damaged parcel replacements: about 15 a month, and a mistake costs at most the €20 limit. Supplier reorders: four a month, and a mistake can tie up €2,000 in green coffee.

Cart recovery happens most and risks least, so it goes first. Replacements come second, inside the €20 limit. Reorders stay with a person, with the agent only drafting them, until the first two have earned trust. These figures are the example's assumptions. The ranking method is the part to keep.

The chatbot era got us used to talking to machines. The next step is systems that do the work, inside limits we set, with a log of every move.

Footnotes

1. Anthropic, Introducing computer use, a new Claude 3.5 Sonnet, and Claude 3.5 Haiku, 22 October 2024, https://www.anthropic.com/news/3-5-models-and-computer-use

2. Anthropic, Introducing the Model Context Protocol, 25 November 2024, https://www.anthropic.com/news/model-context-protocol

3. Maxwell Zeff, OpenAI launches Operator, an AI agent that performs tasks autonomously, TechCrunch, 23 January 2025, https://techcrunch.com/2025/01/23/openai-launches-operator-an-ai-agent-that-performs-tasks-autonomously/

4. Carl Franzen, OpenAI unveils ChatGPT agent, VentureBeat, 17 July 2025, https://venturebeat.com/ai/openai-unveils-chatgpt-agent-that-gives-chatgpt-its-own-computer-to-autonomously-use-your-email-and-web-apps-download-and-create-files-for-you

5. Google for Developers, Announcing the Agent2Agent Protocol (A2A), 9 April 2025, https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/

6. Linux Foundation, Linux Foundation Launches the Agent2Agent Protocol Project, 23 June 2025, https://linuxfoundation.org/press/linux-foundation-launches-the-agent2agent-protocol-project-to-enable-secure-intelligent-communication-between-ai-agents

7. Mastercard, Mastercard Unveils Agent Pay, Pioneering Agentic Payments Technology to Power Commerce in the Age of AI, news release, 29 April 2025, https://s25.q4cdn.com/479285134/files/doc_news/Mastercard-Unveils-Agent-Pay-Pioneering-Agentic-Payments-Technology-to-Power-Commerce-in-the-Age-of-AI-2025.pdf

8. Google Cloud, Announcing Agent Payments Protocol (AP2), 16 September 2025, https://cloud.google.com/blog/products/ai-machine-learning/announcing-agents-to-payments-ap2-protocol

9. Visa, Visa Introduces Trusted Agent Protocol: An Ecosystem-Led Framework for AI Commerce, press release, 14 October 2025, https://usa.visa.com/about-visa/newsroom/press-releases.releaseId.21716.html

10. MCP Core Maintainers, MCP joins the Agentic AI Foundation, Model Context Protocol blog, 9 December 2025, https://blog.modelcontextprotocol.io/posts/2025-12-09-mcp-joins-agentic-ai-foundation/

11. MCP Core Maintainers, MCP Apps: bringing UI capabilities to MCP clients, Model Context Protocol blog, 26 January 2026, https://blog.modelcontextprotocol.io/posts/2026-01-26-mcp-apps/

12. Anthropic, Introducing Claude Sonnet 4.5, 29 September 2025, https://www.anthropic.com/news/claude-sonnet-4-5

13. Intercom, Fin, accessed November 2026, https://fin.ai/

14. Stripe and OpenAI, Agentic Commerce Protocol, accessed November 2026, https://www.agenticcommerce.dev/

15. Solidus, solidus_api README, GitHub, accessed November 2026, https://github.com/solidusio/solidus/blob/main/api/README.md

16. Solidus, Spree::Variant model, GitHub, accessed November 2026, https://github.com/solidusio/solidus/blob/main/core/app/models/spree/variant.rb

17. Schema.org, MerchantReturnPolicy, accessed November 2026, https://schema.org/MerchantReturnPolicy

18. Model Context Protocol, Ruby SDK (the mcp gem), GitHub, accessed November 2026, https://github.com/modelcontextprotocol/ruby-sdk

19. Anthropic, Disrupting the first reported AI orchestrated cyber espionage campaign, 13 November 2025, https://www.anthropic.com/news/disrupting-AI-espionage