Computational Marketing
FeaturesLong read

Agentic AI definitions tell you what a vendor sells, not what the agent does: how a technical buyer turns "goals, tools, approval points" into an acceptance test for a marketing agent

A versioned acceptance test turns vendor claims into pass-or-fail checks.

· 8 min read
Cover illustration for “Agentic AI definitions tell you what a vendor sells, not what the agent does: how a technical buyer turns "goals, tools, approval points" into an acceptance test for a marketing agent”
Features · November 20, 2026 · 8 min read · 1,809 words

A technical B2B buyer evaluating a marketing agent needs more than a definition of agentic AI. The buyer needs to establish whether the system can do a bounded job under agreed conditions. A written, versioned acceptance test turns the vendor’s claims into something testable, with a job description, named tools, distinct approval checkpoints, and a success criterion that can fail.

Why the standard vendor definition of agentic AI is insufficient for a buyer

This is not another exercise in deciding which products deserve the agentic label. The publication’s existing coverage of agent washing and the questions of what a system knows, does, and is allowed to change addresses that earlier decision. Here, the buyer has already accepted that the system is genuinely agentic. The purchase decision remains open. The buyer still needs to assess whether its particular kind of autonomy fits the marketing job.

The architectural properties at issue are goal-directed operation, iterative reasoning, autonomous tool use, and state modification. The critical word is “iteratively.” The agent determines its next step at runtime from the goal and the results of earlier actions, rather than merely generating an answer and making an attached tool call. That distinction explains how the system works. It does not establish which steps the buyer wants it to choose, which changes it may make, or what result will count as useful.

Google Cloud’s definition says agentic systems have autonomy, tool use, and reasoning, but systems can have more or less of each. A system can exhibit them weakly and still fit the broad description. How much independence is the buyer actually purchasing? Without a specific answer, the label leaves the scope of the job unresolved. An acceptance test spells out what the agent should do, its limits, and what it should deliver before the buyer commits to the purchase.

What a written, versioned job description does that a prompt cannot

The agent’s job description belongs in the repository as a version-controlled file that can be diffed. Its location is part of the discipline. A conversation can explain what someone wants, and a prompt can ask for an action, but neither alone keeps a lasting record of the agreed job. When something goes wrong, the buyer needs to inspect the requirements that applied to that run. A prompt in a UI field without version history cannot show what the requirements were for that run.

The file starts with a single, bounded objective that the agent pursues across several steps without repeated prompting. “Improve content output” leaves too much open. It does not say what the agent must deliver or where its responsibility ends. The job description must also distinguish a reactive system that responds to a supplied task from a proactive one that formulates and decomposes the task. Without that distinction, the buyer and vendor may agree on the goal but expect people to give different amounts of guidance.

The output needs an equally concrete form. It might be a pull request, a draft awaiting approval in a named queue, or a structured JSON record. Those artifacts are available for inspection before publication. Their form is itself an acceptance condition, because producing text is different from placing a reviewable draft where the team expects to find it. A run that delivers the wrong kind of artifact has not fulfilled the written job, even if its prose is usable.

Cost belongs in the same file, in tokens or API calls per run, with a line-by-line bill the buyer can check. Scale makes that requirement hard to ignore. Output that meets the requirements does not on its own show that the agent is worth running again and again. When the job later changes, the version history should show the change, its approver, and its date, applying the same change-management discipline used for code. The diff then becomes the record of how the agent’s responsibilities have expanded or narrowed.

Mapping the agent’s tool access and how it widens

The job description sets the task, but the access layer sets what the agent can actually do. Each claimed capability must map to a named tool, an observable system log entry, and an explicit access boundary approved by the buyer. A demo can leave that mapping unstated. Production cannot safely treat it as implied, because a statement such as “the agent can manage content” says nothing precise about which systems it may read or change.

Autonomous tool use requires an access control layer because the model’s choice of an action is not permission to perform it. The infrastructure must enforce the controls a human would otherwise provide. State modification also needs audit logging. The record must identify who authorized the action, the agent’s reasoning, the exact tool input, and what the tool returned. Those details answer different questions, so a record that merely says the run completed is not a substitute.

For a marketing agent, day-one access has a narrow shape. The agent can read sources and write to a draft queue, but it has no publish rights. Access then widens through named decisions, rather than just because people have come to trust the agent more. Each new permission needs a named approver, a logged decision, and an entry with a date in the job description. This makes access a schedule of authorized changes.

The same controls need to be reachable through both an API and a person’s use of a UI. Otherwise, what the acceptance test can observe is limited by the buyer’s inability to instrument the tool access policy. Defaults are neither an audit trail nor a diffable record when a team needs to understand what went wrong at 2 a.m. on a Friday.

Approval checkpoints are not interchangeable in a content run

A single “approve” button can conceal three different decisions. Research, drafting, and publishing each need a different judgment, and agreement at one stage does not settle what to do at the next. A real source can support a claim the firm should not make. A sound draft can still be wrong for a particular audience or moment. Collapsing those decisions turns human review into a rubber stamp rather than a meaningful boundary on the agent’s work.

At the research checkpoint, a named person confirms that the retrieved sources exist, are attributable, and provide sufficient evidence. This check establishes the factual basis for editorial work. The reviewer assesses whether the evidence can support the work that follows. Keeping this decision apart from the others makes clear what the reviewer is responsible for. It also prevents approval of the sources from being mistaken for approval of every claim the agent later builds from them.

At the draft checkpoint, a named person decides whether the firm will stand behind the claim the piece makes. This positioning and legal-exposure check asks something that source validation alone cannot answer. At publication, the judgment changes again to timing, channel, and audience. The named approver is deciding whether distribution is right in context.

A per-playbook approval policy makes these distinctions operational. The rule attaches to a named recipe for a content type, rather than treating every run through the pipeline alike. Risk determines the depth of review. A draft for use inside the firm needs fewer reviewers than a customer-facing email, which needs fewer than a piece that makes pricing or health claims. The acceptance test therefore names the tier for each playbook, allowing a low-risk one to ship automatically while a higher-risk one waits for a named reviewer at the specified step.

The falsifiable success criterion and what doing the job means

The final component is a criterion that can be judged true or false. Without it, the acceptance test is still a demo script. It may show that the agent works when conditions are good, but it does not show that the buyer got what they were paying for. What result would make the pilot fail? If there is no clear answer, successful execution can be confused with successful work.

The criterion first names the delivered artifact, such as a published post, a filed pull request, or a populated CMS record. “The agent ran successfully” is not an output. The artifact must match the job and its permissions, so a draft-only assignment cannot count publication as evidence of success. Where approved publication is the agreed outcome, evaluation against the actual contract requires reaching that outcome.

Quality must also be specified before the output counts. A draft that requires a reviewer to rewrite more than half of it has not succeeded, even if the agent completed every step. Completion alone is too weak a standard. The criterion also needs a cost ceiling per run, because usable output at an unacceptable cost is not a successful purchase.

Finally, the test needs a time window and a volume. “The agent will produce content” cannot fail in any useful, bounded sense. “The agent will produce three approved, published posts per week for four weeks at or below X tokens per post” can, once X is agreed and the quality requirement is attached. The output, quality, cost, and schedule must all hold for the result to pass. The acceptance test is therefore the first artifact a serious buyer ships, before the agent ships anything.

When a simpler workflow beats the agent and how the acceptance test reveals that early

Writing the job down may expose a different problem from the one the vendor proposes to solve. Many agent projects fail because the clearly stated job describes a fixed workflow that would be cheaper and more reliable without an agent. This reflects a mismatch between the kind of system purchased and the decisions the work actually requires.

Automation Anywhere’s buyer’s guide distinguishes traditional RPA, which automates defined sequences reliably, from agentic platforms suited to genuine exception-handling, cross-system reasoning, or runtime decision-making. A marketing pipeline that follows the same six steps on a fixed schedule is closer to the former case. The relevant distinction depends on whether the workflow needs a system to choose a path that cannot be specified in advance.

For a buyer, the early test is straightforward. If every step can be pre-specified and reasoning is never needed to handle an exception, the job describes automation. The buyer should buy automation in that case. Choosing the simpler system is a reasonable outcome of the evaluation.

Gartner projects that over 40% of agentic AI projects will be canceled by the end of 2027 because of escalating costs, unclear business value, or inadequate risk controls. Writing the acceptance test early makes costs, expected value, and what the agent is allowed to do part of the choice to buy, before the pilot has to uncover them. Whether the result is an agent or a simpler workflow, a written, versioned, falsifiable acceptance test is the professional standard for procuring an autonomous system, regardless of what the vendor calls it.

Sources

  1. What is agentic AI? Definition and differentiators
  2. Gartner: Over 40% of Agentic AI Projects Will Be Canceled by End 2027
  3. AI Agents and Agentic AI-Navigating a Plethora of Concepts for Future Manufacturing
  4. Building effective AI agents

More in Features