Agentic AI and Robotics: What Happens When Chatbots Get Hands and Feet?

An essay from 9horsemen's founder. For practical help running a business, see the blog.

Part 3 of 4 in the AI for Founders series. See all parts.

Listen to this episode of Why Your Software Sucks on Spotify.

TL;DR:

• Traditional generative chatbots are passive advisors stuck behind a screen; Agentic AI turns the model into an active operator that plans multi-step tasks, uses external software tools, and evaluates its own results.
• Multi-agent architectures mirror human business operations: specialised software agents act as researchers, writers, and compliance auditors, handing tasks off across an automated digital assembly line.
• Embodied AI (robotics) connects digital reasoning models to physical actuators, but founders must ignore Hollywood humanoid fantasies: real near-term robotics ROI lives in specialised warehouse logistics, repetitive factory assembly, and automated facility maintenance.

Agentic AI is AI that doesn’t just answer: it plans a task, uses software tools to carry it out, checks the result and tries again. Here’s how agents work, why one model isn’t enough, where robots fit in, and how to get your business ready.

What is the difference between generative AI and agentic AI?

Generative AI answers inside a chat box; agentic AI acts outside it, using tools to finish a task without you passing along every step.

In 2023, the business world became obsessed with the chat box. Every software platform added a conversational interface: you typed a sentence, and a Large Language Model typed a sentence back.

For a brief moment, it felt like magic. But within twelve months, practical entrepreneurs hit what engineers call the Glass Box Problem.

Imagine hiring an executive assistant. You sit them in an enclosed glass booth in the corner of your office.

• They have read every business book on Earth.
• They can draft a memo in three seconds.
• They can translate your quarterly goals into German, Japanese, or French.

Then you tell them: “Our top client is furious about a delayed shipment. Go figure out what happened, issue a partial refund on their invoice in QuickBooks, adjust the inventory count in Shopify, and send them an updated tracking link.”

The assistant inside the glass booth looks back at you and says:

“Here is a 5-step suggested strategy for how you can log into QuickBooks, update Shopify, and draft an apology email!”

They cannot actually do it. They don’t have hands. They don’t have access to your keyboard. They cannot click a button, open an app, run a calculation, or execute a transaction.

They are an advisor who can only talk, leaving you or your employees to do the actual mechanical clicking.

+-------------------------------------------------------------+
|                 THE EVOLUTION OF AI WORKFLOWS               |
|                                                             |
|   1. GENERATIVE CHATBOT (Passive Advisor)                   |
|      User: "How do I process a refund for Order #402?"      |
|      AI:   "Step 1: Open Stripe. Step 2: Click Refund..."   |
|                                                             |
|   2. AGENTIC AI (Autonomous Operator)                       |
|      User: "Resolve the dispute on Order #402."             |
|      AI:   [Checks CRM] -> [Verifies Tracking] ->           |
|            [Executes Stripe Refund] -> [Updates ERP] ->     |
|            "Resolved: Refund issued; inventory adjusted."   |
+-------------------------------------------------------------+

The conversational chat era was merely the diagnostic phase of modern artificial intelligence. The transition underway in commercial computing is the shift from Generative AI (chatbots that suggest) to Agentic AI (autonomous software that acts).

And when you take those digital actions and connect them to physical motors, sensors, and wheels, you enter the realm of Embodied AI and Robotics.

To prepare your company for what is arriving over the next three to five years, you do not need to build software engines. You need to understand how digital agents operate, where they break, and why giving a computer hands changes the unit economics of small and medium businesses.

How does agentic AI work?

An agent runs in a loop: it reasons about the next step, acts with a tool, looks at the result and repeats until the job is done.

What turns a standard language model into an “agent”?

It is not a larger, smarter model. It is the software scaffolding wrapped around the model. In traditional generative setups, the process is a straight line: Input Prompt -> Output Text.

An agent operates in a continuous, autonomous cycle called a ReAct Loop (Reason + Act + Observe).

                 +-----------------------+
                 |     PRIMARY GOAL      |
                 +-----------------------+
                             |
                             v
+-------------------> [ 1. REASON ] <--------------------+
|       Evaluates goal: "What is my next step?"          |
|                            |                           |
|                            v                           |
|                     [ 2. ACT ]                         |
|       Calls an external tool: API, Search, Database    |
|                            |                           |
|                            v                           |
|                   [ 3. OBSERVE ]                       |
|       Reads the tool's result: "Did that work?"        |
|                            |                           |
+------- [ Goal Complete? No: Loop / Yes: Finish ] ------+

To see this loop in action, look at how a human procurement manager books emergency business travel versus how an agent executes the same task:

The Scenario: An Urgent Flight to Chicago

You tell your digital agent: “Book me a flight to Chicago for tomorrow morning’s client meeting. Keep the ticket under $600, ensure it has Wi-Fi, and schedule around my 9:00 AM calendar hold.”

Here is how the internal loop executes without you typing another word:

1. Reason: The agent breaks the abstract instruction down into sequential requirements: check calendar availability, search flights matching arrival constraints, filter for amenities, compare prices, purchase ticket.
2. Act (Tool Call 1): The agent calls your Google Calendar API.
3. Observe: It sees an internal team sync from 9:00 AM to 9:30 AM. It determines that any flight landing after 8:15 AM will cause a conflict.
4. Reason: “I need a flight that departs at dawn and lands by 8:00 AM.”
5. Act (Tool Call 2): It sends a search query to an airline aggregator API for morning departures.
6. Observe: Flight A lands at 7:45 AM and costs $520, but has no Wi-Fi. Flight B lands at 7:55 AM, has high-speed Wi-Fi, and costs $580. Flight C costs $450, but lands at 10:30 AM.
7. Reason: “Flight B is the only flight meeting all constraints (under $600, has Wi-Fi, lands before the 9:00 AM meeting).”
8. Act (Tool Call 3): It calls the corporate booking engine API, reserves the seat using your stored corporate card, logs the PDF receipt to your expense tracker, and updates your calendar.
9. Final Output: It pings your Slack: “Booked Flight B on American Airlines for $580. Boarding pass added to your Apple Wallet; expense logged to QuickBooks.”

Notice what happened: The AI did not ask for permission at every step. It was given an objective, a set of constraints, access to external software tools, and the authority to iterate until the condition was met.

The Four Organs of an AI Agent

For an agent to function reliably inside an enterprise, it requires four architectural components:

• The Planning Brain: A high-capability language model that breaks messy, open-ended human requests into small, logically sequential code steps.
• The Tool Shed (APIs & Sandboxes): Standardised programmatic connectors that allow the model to interact with the world: reading email inboxes, running database queries, executing Python scripts, opening browser windows, or triggering payment gateways.
• Memory Systems:
  • Short-term memory: The scratchpad where the agent remembers what it did three seconds ago during the active task.
  • Long-term memory: A structured database storing your company’s permanent context—customer profiles, pricing tiers, past decisions, and operating policies.
• Deterministic Guardrails: The non-negotiable software boundaries that prevent catastrophe (e.g., “Under no circumstances can this system authorise an external payout exceeding $1,000 without a human password”).

Why does one AI agent fail at big tasks?

Because small mistakes compound: over a long chain of steps one model drifts off course, so reliable systems split the work between specialised agents.

When founders first experiment with autonomous agents, they usually try to build a “Swiss Army Knife” agent. They prompt a single model: “You are an autonomous marketing director, copywriter, SEO specialist, web developer, and legal compliance officer. Run our product launch.”

This approach inevitably fails.

As an execution loop grows longer, a single model suffers from context drift and error compounding. If an agent makes a tiny 5% mathematical error on Step 2 of a 15-step task, that error cascades down the line. By Step 12, the system is operating in complete hallucination, burning through thousands of API tokens while generating garbage.

The solution mirrors human organizational design: Multi-Agent Systems.

                          [ FOUNDER GOAL ]
                                 |
                                 v
                     +-----------------------+
                     |  ORCHESTRATOR AGENT   |
                     |  (The Project Mgr)    |
                     +-----------------------+
                                 |
        +------------------------+------------------------+
        |                                                 |
        v                                                 v
+-----------------------+                         +-----------------------+
|   RESEARCHER AGENT    |                         |    EXECUTION AGENT    |
|   - Scrapes web data  |                         |   - Writes code       |
|   - Queries SQL DB    |                         |   - Calls APIs        |
+-----------------------+                         +-----------------------+
        |                                                 |
        +------------------------+------------------------+
                                 |
                                 v
                     +-----------------------+
                     |    CRITIC / AUDITOR   |
                     |  (Quality Assurance)  |
                     +-----------------------+
                                 |
                      [ Verified Output ]

Instead of asking one model to do everything, modern enterprise frameworks deploy specialised software agents that talk to one another:

1. The Orchestrator (Project Manager): Does not execute tasks directly. It ingests the founder’s high-level goal, writes an execution plan, delegates micro-tasks to specialised sub-agents, and tracks timeline completion.
2. The Researcher: A lightweight agent optimised strictly for search, data retrieval, and document extraction. It scours spreadsheets, internal wikis, or the web, condensing raw facts into clean summaries.
3. The Execution Worker: An agent built to write structured code, populate databases, or draft customer-facing text based strictly on the Researcher’s findings.
4. The Auditor / Critic: A skeptical agent tasked with finding flaws. Its prompt explicitly instructs it: “Check the Execution Worker’s output against our internal compliance rules and factual sources. Reject the work if any calculations or claims do not balance”.

What This Looks Like in a Real Small Business

Consider a small e-commerce brand that sells ergonomic office furniture. Today, handling a complex supplier dispute requires the founder or an operations manager to spend four hours collecting emails, cross-referencing shipping manifests, drafting emails, and updating accounting sheets.

In an agentic workflow:

• Agent A (Triage): Detects an incoming email from a freight carrier stating that a container of standing desks is stuck in customs due to missing tariff codes.
• Agent B (Database Specialist): Pulls the commercial invoices from Google Drive, cross-references the international Harmonized Tariff Schedule (HTS) codes, and isolates the specific clerical typo in the freight forwarder’s paperwork.
• Agent C (Operations Drafter): Fills out the corrected customs clearance form via an online portal API and drafts an expedited release letter.
• Agent D (Auditor): Checks the tariff code against your tax history to confirm it doesn’t accidentally trigger a higher duty rate.
• Human Checkpoint: The operations manager receives a single notification on their phone: “Customs delay resolved on Container #88. Corrected form prepared. Click here to approve submission and pay the $150 filing fee.”

The business moved from manual administrative drudgery to an executive review process. The humans stop acting as data couriers and start acting as flight controllers.

What is embodied AI?

Embodied AI puts the same reasoning engine into a physical machine, so an agent can act in the real world, not just in software.

So far, we have discussed agents that live entirely within digital systems—moving bits, reading databases, and triggering APIs.

The next frontier is taking that same reasoning engine and installing it into physical machinery. This is Embodied AI.

For decades, the public’s understanding of robotics has been shaped by Hollywood: either the Terminator marching across a post-apocalyptic wasteland, or the Jetsons’ robotic maid Rosie cracking jokes while flipping pancakes.

Both models completely misunderstand the reality of robotics engineering.

Moravec’s Paradox: Why Simple Things Are Hard

In the 1980s, computer scientist Hans Moravec made an observation that explains why robotics has lagged behind software:

“It is comparatively easy to make computers exhibit adult level performance on intelligence tests or playing checkers, and difficult or impossible to give them the skills of a one-year-old when it comes to perception and mobility.”

It took thirty years for computers to beat a human grandmaster at chess. But chess is simple: it has an 8x8 grid, 32 pieces, and strict mathematical rules.

Consider what your brain does when you grab an egg out of a carton:

• Your visual cortex measures the distance and lighting.
• Your fingers position themselves to distribute force evenly across a fragile, curved surface.
• If the egg is slippery, your skin sensors detect micro-slippage in milliseconds and increase fingertip tension just enough to maintain grip without crushing the shell.
• Your shoulder, elbow, and wrist muscles compute complex continuous torque equations in real time to lift the egg smoothly against gravity.

For sixty years, industrial factory robots were completely blind and rigid. A robotic arm on a car assembly line could weld a seam with sub-millimeter precision, but only because the car frame was placed in the exact same spot every time. If you nudged the car frame two inches to the left, the robot arm would weld empty air, or punch a hole straight through the door.

The Revolution: Vision-Language-Action (VLA) Models

What changed in the last two years?

Roboticists stopped trying to manually program kinematic physics equations for every movement. Instead, they adapted the same neural network architectures that power Large Language Models and built Vision-Language-Action (VLA) models.

[ MULTIMODAL CAMERAS ] ===> Sees: A cardboard box tipped over on its side.
         +
[ LANGUAGE DIRECTIVE ] ===> Reads: "Clear the loading bay aisle."
         |
         v
+-------------------------------------------------------------+
|               VISION-LANGUAGE-ACTION (VLA) MODEL            |
|                                                             |
|   Translates semantic visual concepts into dynamic motor    |
|   actuation commands (voltage, joint angles, grip torque).  |
+-------------------------------------------------------------+
         |
         v
[ PHYSICAL ROBOTIC ARM ] => Adjusts fingers dynamically, lifts box.

Instead of predicting the next word in a sentence, a VLA model predicts the next physical movement in space:

• How many degrees should the elbow actuator rotate?
• How many newtons of pressure should the rubber fingertips apply?
• How does the trajectory need to shift if an obstacle enters the robot’s visual path?

Robots are no longer blind machines following rigid tracks. They are becoming adaptive sensory systems capable of operating in unstructured, messy human environments.

The Reality Check for Founders: Where Robots Actually Work

If you are running a business today, do not waste time wondering when a humanoid robot will sit at your front desk to greet clients. The humanoid form factor (two arms, two legs) is technically brilliant, but it is expensive, power-hungry, and mechanically complex.

Real, profitable enterprise robotics is landing in three specific, unglamorous categories:

What will agentic AI change for small businesses?

Software stops being a tool your team clicks through and becomes a digital workforce they manage, which changes how many people a business needs and what they spend their day on.

We are entering a phase where the division between “software” and “labour” begins to dissolve. For the last forty years, software was a tool that your employees sat down to use. In the agentic era, software becomes a digital workforce that your employees manage.

Here is what founders must prepare for over the next 24 to 36 months:

1. The Death of Point-and-Click SaaS

Today, if you want to run an email marketing campaign, an employee opens a browser, logs into a tool like Mailchimp or HubSpot, clicks through seven menus, sets up a workflow filter, pastes copy, tests links, and clicks “Schedule.”

In an agentic ecosystem, human user interfaces (UI) become obsolete for operational workflows. Software companies are rapidly redesigning their platforms to be controlled via APIs and agent protocols (like Anthropic’s Model Context Protocol or standardised REST endpoints) rather than visual buttons. Your employees will not spend their days clicking buttons in complex enterprise software; they will specify operational outcomes to an orchestrator agent that calls those platforms in the background.

2. The 3-Person, $10-Million Enterprise

Historically, scaling a company’s revenue required linearly scaling headcount. If you wanted to double your customer support volume, you had to hire more support reps. If you wanted to double your outbound sales cadence, you had to hire more business development reps.

Agentic systems break that linear relationship.

A lean team of three highly skilled operators—supported by an array of specialised, self-auditing agents—can manage customer service, outbound prospecting, financial reconciliations, and inventory routing at a scale that once required forty full-time employees.

The competitive advantage swings violently away from large organisations with massive, bureaucratic payrolls towards nimble, highly automated micro-enterprises.

3. The Dangerous Illusion: “Zero Human Oversight”

The greatest risk to businesses over the next three years is not that AI fails, but that founders trust it too much. Vendors will attempt to sell you “completely hands-off, fully autonomous operations.”

Do not fall for this.

When you allow an agentic loop to run with unrestricted access to real-world resources, small edge cases can become financial disasters:

• An autonomous marketing agent misinterprets a brand directive and spends an entire month’s $25,000 ad budget on misconfigured campaigns in three hours.
• A customer dispute agent gets caught in a logical loop with an aggressive customer and issues twenty-five consecutive refunds to the same account.
• A code-execution agent misreads a database migration script and accidentally deletes five years of historical transaction records.

The gold standard for production systems is not full autonomy; it is Human-in-the-Loop (HITL) Checkpoints.

The agent does 95% of the heavy lifting: gathering data, evaluating rules, planning the trajectory, and drafting the action. But the final gate—the button that actually moves money, publishes legal text, or deletes data—must sit behind a human confirmation screen.

How do you get your business ready for AI agents?

Write down how your processes work, choose software with open connections (APIs), give agents only the access they need, and start with high-volume, repetitive work.

If you want your business to benefit from the agentic transition, you do not need to start coding neural networks. You need to prepare your operational foundation so agents can actually interface with your company.

+-------------------------------------------------------------+
|                 AGENTIC READINESS CHECKLIST                 |
|                                                             |
|   [ ] Step 1: Eliminate tribal knowledge; write strict SOPs |
|   [ ] Step 2: Modernize your stack (API-accessible tools)   |
|   [ ] Step 3: Implement Least-Privilege Access Controls     |
|   [ ] Step 4: Establish Human-in-the-Loop approval gates   |
+-------------------------------------------------------------+

1. Codify Your Standard Operating Procedures (SOPs): An AI agent cannot automate a process that your own human team doesn’t understand. If your sales intake or invoicing process relies on “tribal knowledge” locked inside a senior manager’s head, an agent will fail instantly. Document your business workflows into step-by-step logic trees: If condition X happens, check system Y, then execute action Z.
2. Audit Your Software Stack for Modern APIs: Stop buying legacy software that locks your data behind closed walls. If your CRM, ERP, or inventory system doesn’t have an open, well-documented REST API or webhook functionality, you will not be able to connect modern autonomous agents to it.
3. Enforce the Principle of Least Privilege: Never hand an AI agent master administrator credentials. If you build an agent to monitor incoming customer support emails, give it access only to read those emails and draft responses. Do not give it access to your production database or billing configuration.
4. Identify Your “High-Friction, High-Volume” Workflows: Don’t attempt to automate your company’s high-level strategy or creative direction. Look for the monotonous, multi-app workflows that drain your employees’ energy: cross-referencing spreadsheets, matching invoices to receipts, onboarding standard clients, or scheduling freight shipments. That is where agentic automation delivers immediate, defensible ROI.

Autonomous agents and physical robotics will keep dominating venture headlines, but real leverage doesn’t come from chasing speculative humanoid futures. It comes from simple, dependable software that quietly runs the repetitive parts of a business. That’s what we build at 9horsemen. Our first product, Gallop, builds a website, online booking and business app for a local service business from a short conversation. If you’re building software of your own, the other essays and the podcast Why Your Software Sucks are where I dig into it.