What Is Agentic AI? A Plain-English Guide

Agentic AI is software that can take multi-step actions toward a goal - drafting, calling tools, revising - while remaining inside boundaries set by humans. In our studio that means seniors decide architecture, taste and release; agents execute implementation inside that remit. It is not “AI that runs the company”, and it is not a chatbot with a new label.

Agentic systems plan and act across steps rather than only returning a single reply. They may read a codebase, propose a patch, run tests, open a pull request, or call an API - then loop on feedback. The agentic bit is the loop and the tools. The safe bit, when it exists, is human-set goals, permissions and release authority. Without those, you have unsupervised automation with better marketing. With them, you get more implementation per senior hour without handing production keys to a model that cannot own the outcome.

That definition is the positioning bet behind our delivery. We publish the receipts in the AI agent build log and the build-time dataset. Service home: AI development.

Why the definition is contested (and why buyers should care)

Vendors stretch “agentic” because it sells. Sometimes they mean a chatbot with memory. Sometimes they mean a cron job with an LLM in the middle. Sometimes they mean a coding agent that opens pull requests. The underlying tech overlaps; the risk profile does not.

Buyers should care because pricing, liability and ops staffing follow the risk profile. A generative draft tool that a human pastes from is low operational risk. An agent that can refund a customer or deploy code is high operational risk. If the proposal uses one word for both, the commercial terms are probably wrong for at least one of them.

Our rule of thumb: if it can take an action in a system of record, call it agentic, demand gates, and price Harden. If it only suggests text, call it generative assist and keep the workflow honest.

Generative vs agentic: the difference that matters to a buyer

Generative AI produces content from a prompt: text, images, code snippets, summaries. One shot or a short chat. Useful for drafts. It does not, by itself, operate your backlog.

Agentic AI pursues a goal across steps with tools: edit files, query data, call services, revise when checks fail. The output is not only words - it is a trail of actions.

Buyer-relevant differences:

Question	Generative	Agentic
What did I buy?	Drafts and suggestions	Actions inside a workflow
How does work move?	Human copies/pastes	Agent proposes changes in context
Where does risk live?	Bad advice you might paste	Bad actions you might auto-merge
What must you add?	Editorial judgement	Permissions, review gates, evals

A team using ChatGPT in a browser is doing generative work. A team with coding agents opening diffs against a repo, plus humans merging, is doing agentic delivery. Both can exist in the same company. Only one changes how software ships.

Marketing often blurs them because “agentic” sounds newer. If a vendor cannot explain the tools, the permissions and who signs release, they are selling generative theatre.

What agents do in our actual delivery pipeline

Theory is cheap. Production is where definitions get tested. We use agents on client and internal work every week - websites, marketplaces, SaaS and internal ops - under the same rule: humans lead, agents execute inside a written remit. Concrete jobs:

Implementation under architecture. Components, CRUD, refactors, test stubs, documentation drafts against a locked design system. This is where throughput shows up - the 5x speed framing versus our own pre-agent baseline for comparable Build work.

Bulk consistency work. Internal links, frontmatter alignment, alt-text inventories, repetitive UI variants. Humans hate this work and skip it; agents do it when the rules are explicit.

Research assistance. Clustering notes, summarising packs, drafting options for a human to cut. Map and Blueprint stay human-led; agents accelerate inputs, not the commercial decision.

Production AI features. Not only “AI to build software” but “AI inside the product”: RAG systems, compare tools, ML models such as the Plastor shipping-cost model trained on 13,371 historic orders. Same discipline - evaluate, gate, monitor.

Multi-instance programmes. When a shared kit exists, agents multiply instances. We have shipped 100+ branded sites in one rollout pattern historically - the lesson is coherence first, automation second.

What agents do not do in our pipeline:

Set the commercial band
Invent product claims
Bypass Harden
Own the 3am incident

For outcome-shaped automation sold as a service category, see AI automation agency. For QA specifically, see AI agent QA.

Where humans stay in charge

Agentic mastery is a people system.

Review gates. Every production diff has a human owner. Agents draft; humans accept, reject or narrow.

Release authority. Go-live is a named decision. Models do not get deploy keys as a personality trait.

Claims and corpus discipline. Numbers come from a sourced fact sheet, not from the model’s confidence. Agents invent tidy statistics; humans delete them.

Assurance standard. Accessibility, performance, security review, evaluation harnesses for model features. Skipping Harden to protect a speed headline recreates demo culture.

Failure policy. When an agent is confidently wrong - and they will be - the path is rollback, patch, and a note in the log. Hiding failure is how washing spreads.

Client accountability. We explain the split in plain English: you are hiring seniors who wield agents, not a black box that “does AI”. After 20 years of shipping, that accountability model did not change when the tools did.

If a pitch deck cannot name the human gates, treat the agents as unattended interns with write access.

What is agentic AI in simple terms?

Agentic AI is AI that can take a sequence of actions toward a goal using tools, while - if you run it safely - humans still set the goal, limits and final approval.

What is the difference between generative AI and agentic AI?

Generative AI creates a response; agentic AI works through steps and tools to change a system or complete a workflow - which is why review gates matter more.

What are AI agents used for in business?

In business they draft and modify software, automate multi-step ops workflows, retrieve and act on internal knowledge, and power product features - always with clearer ROI when a human owns exceptions and release.

Is agentic AI safe to use on client work?

It is safe when permissions are tight, diffs are reviewed, evaluation exists for model features, and a human owns release; it is unsafe when agents merge unsupervised or operate on production data without audit trails.

Safety is not a vibe. It is permissions, logs, evals and a named human. Anything less is a demo with production credentials.

Anti-patterns that steal the word “agentic”

Chatbot on the homepage. Useful sometimes. Not agentic delivery of your product roadmap.

Unattended repo write access. An agent with merge rights and no human gate is not innovation - it is unsupervised junior access with better autocomplete.

Prompt theatre. Long screenshots of clever prompts without diffs, tests or outcomes. Buyers should ask for the merge trail.

Metric laundering. Claiming 10x on a whole programme while measuring only the hour someone spent generating a colour palette.

Scope expansion by helpfulness. Agents that “also refactor” unrelated modules create review debt. Remit must be written down.

Demo data cosplay. Models that look brilliant on cleaned samples and collapse on production mess. Evaluation sets should look like Tuesday afternoon, not the brochure.

If a vendor’s agentic story trips two or more of these, keep the definition and change the vendor.

How to evaluate an agentic vendor in one meeting

Ask for:

A recent diff an agent drafted and a human changed - what changed and why
The permission model (what the agent can touch)
The last production incident involving model output and how it was handled
Which phases of their process are explicitly human-led
How they price extras when the agent explores outside the brief

You are listening for operational detail. Longevity and review volume tell you a firm exists; the answers to those five tell you whether agentic delivery is practised or performed.

The agent loop: goal, tools, memory, evals

Strip the marketing and an agent run is a loop with four moving parts.

Goal. A written outcome the agent can pursue without inventing a new brief. “Add Stripe webhook handling for invoice.paid and write tests” is a goal. “Improve the billing experience” is not. Soft goals produce soft diffs and review debt.

Tools. The functions the agent may call: read or edit files, run tests, query a database, hit a staging API, open a pull request. Tool design is permission design. Read-only tools on production data are a different risk class from write tools on a feature branch. If the proposal cannot list tools and scopes, the loop is undefined.

Memory. What the agent carries between steps: the conversation transcript, retrieved snippets, a scratchpad of decisions, sometimes a vector store over the repo or docs. Memory is useful and dangerous. Useful because the agent does not re-read the entire codebase on every turn. Dangerous because a wrong early assumption can poison every later step until a human resets context.

Evals. Fixed cases you score so “better” means something measurable: unit tests, golden prompts, citation checks, regression journeys. Without evals, the loop optimises for sounding finished. With evals, the loop has a stop condition that is not the agent’s self-confidence.

A production harness wires those four together: remit in, permissions set, logging on, human merge at the end. That is agentic delivery. A chat window with plugins and no harness is generative assist wearing a louder coat.

A worked agent run with human gates

Concrete shape from how we ship implementation work (composite of real runs, not a client case study).

Human sets remit. Senior writes: change X module only; match existing patterns; do not touch payments config; open a draft PR; stop after tests fail twice and ask. Remit lives in the ticket and the agent brief.
Agent plans. Lists files to touch, tests to add, risks it sees. Human skims the plan when the change is wide; skips skim when the remit is narrow and the agent has a clean track record on that surface.
Agent implements. Edits on a branch, runs the test command it is allowed to run, fixes obvious failures inside the remit.
Gate: diff review. Human reads the diff for scope creep, security smells, and “helpfulness” outside the brief. Rejects unsolicited refactors.
Gate: test intent. Human checks that new tests assert the intended behaviour, not the bug. Agents sometimes encode the broken state as correct.
Gate: release. Named human merges and deploys. The agent does not hold production keys.

What the agent owned: drafting and iterating inside the branch. What the human owned: architecture fit, taste, claim accuracy, and whether the change ships. Time saved sits in implementation hours; time spent sits in review that actually reads the diff. That trade is the whole economic story of agentic delivery.

Failure modes and the controls that contain them

Three failure modes show up often enough to name the control beside each.

Tool misuse. The agent calls a destructive tool, writes outside the remit, or treats staging credentials as a playground. Control: least-privilege tools, path allowlists, no production write access, and a hard stop when the agent requests a tool outside the brief. Log every tool call.

Runaway loops. The agent retries the same failing approach, burns tokens, and “helps” by expanding scope. Control: step budgets, wall-clock limits, “fail twice then escalate” rules, and human review when the plan changes mid-run. Speed without a budget is just a larger bill.

Hallucinated success. The agent declares done because the output looks polished: green tests that assert the bug, confident summaries that invent an API, brand facts that were never in the corpus. Control: evals that include awkward cases, human review of test intent, and a claims gate against sourced facts before anything customer-facing ships. Confidence is not a status field.

If a vendor cannot name these three and the matching controls, they are selling demos. Demanding the controls is buyer hygiene, not pedantry.

What agentic delivery means for cost and speed

Compression lives mainly in Build: more implementation per senior hour when harnesses and review discipline are real. Map and Blueprint still take human judgement - pretending discovery 5x’s creates brittle scopes. Harden still needs human release authority - pretending QA is optional creates outages.

Commercial framing we publish with method:

Pace: about 5x on compressible implementation versus our own pre-agent baseline
Cost: roughly half a traditional agency bench for comparable Blueprint scope
Not included in the fairy tale: client content freezes, legal review, third-party API waits, scope changes mid-flight

Extras outside a fixed band remain transparent fixed change bands. Speed does not turn scope creep into free work. Full method: AI-accelerated delivery build-time data.

For buyers comparing shops, ask:

What baseline is the speed claim measured against?
Which phases are included?
Who merges?
What failed last month?

Vendors who answer those four are worth a second meeting. Vendors who pivot to vibes are selling generative AI in an agentic costume.

Agentic AI inside products vs agentic AI in the delivery team

Two different buys that share a vocabulary.

Inside the product. Features users touch: assistants, retrieval over private docs, scoring models, triage tools. Success looks like task completion, citation quality, reduced handle time, or better decisions - with monitoring when quality drifts. The Plastor model on 13,371 orders sits here. So do RAG compare tools.

Inside the delivery team. How the software gets built: coding agents, test generation, bulk content transforms, research assistance. Success looks like more implementation per senior hour without lowering the release bar. The build log and build-time data sit here.

You can buy either, both, or neither. Confusing them produces proposals that mix a customer chatbot with a claim that the website will somehow build itself. Keep the invoices separate in your head even if one agency can deliver both.

A plain glossary for non-specialists

Model: the trained system that predicts the next tokens or scores an input
Tool use: letting that system call functions (search, edit a file, hit an API)
Agent: a loop that plans, uses tools, and revises toward a goal
Harness: the scaffolding of permissions, prompts, tests and logging around the agent
Eval: a fixed set of cases you score so “better” means something measurable
Human release authority: a person who decides the change ships

You do not need the glossary to buy. You need it to detect when someone is selling fog. If a deck cannot map its claims onto those six terms without hand-waving, the delivery model is not ready for your production systems.

We did not invent agentic AI. We operationalised it inside an agency that already ran client systems and seven operated marketplaces on the balance sheet. Humans lead. Agents execute. The receipts stay public on purpose.

The short version we want buyers to remember: agentic means actions, generative means drafts, and safe means humans still own the merge. Everything else is packaging. When the packaging gets loud, ask for the review trail. If they cannot show one, you already have your answer.

For agentic delivery on a product or platform build, the door is AI development.