Most AI Agent Consulting Is Prompt Coaching
AI agent consulting must ship bounded decisions, least-privilege tool access, and replayable traces by Day 7. The OpenAI Decisions API costs $0.10 per million tokens. If Week 1 ends with workshops, you bought prompt coaching.
Most AI Agent Consulting Is Prompt Coaching
AI agent consulting is paid work that turns a business process into a controlled AI system.
That system should make decisions, take approved actions, and leave a complete record.
If your first week ends with workshops and prompt templates, you bought expensive ChatGPT training.
The Model Isn't Your Biggest Risk
Agents fail when people give probabilistic models broad access to real systems.
A polished prompt doesn't fix that problem.
Suppose an AI sales agent can access HubSpot. It shouldn't get permission to edit every contact, export lists, or delete deals.
That's handing an intern the master password.
The same rule applies to marketing agents. Drafting a campaign is different from publishing it.
Changing a headline is different from raising a Meta Ads budget.
The lesson isn't new.
The Sarbanes-Oxley Act arrived in 2002 after Enron and WorldCom collapsed. Businesses responded with approvals, role controls, and audit records.
Better instructions didn't make software safer. Systems became safer because they limited what each person could do.
AI agents need the same treatment.
Every production agent needs three layers:
1. A decision layer that chooses between approved options. 2. Limited tool access that blocks unapproved actions. 3. Replayable traces that show exactly what happened.
Prompts belong inside this structure. They aren't the structure.
Most AI agent consulting firms reverse that order. They spend two weeks polishing tone before securing Salesforce access.
Start with strategy. Add controls. Then write prompts.
OpenAI's Decisions API Belongs in the Control Layer
OpenAI released the Decisions API on October 22, 2026.
It uses GPT-6 Luna for bounded questions. It returns a probability, choice, or score.
Agents need a fixed set of available actions.
A sales agent shouldn't ask, "What should I do now?" That question allows too much freedom.
Ask this instead:
> Choose one action: route to sales, add to nurture, request clarification, or reject.
The agent receives a fixed menu. Your application decides what each answer permits.
OpenAI says the Decisions API runs up to 10 times faster than Luna through Responses. It costs $0.10 per million input tokens.
Cached input costs $0.01 per million tokens. OpenAI charges nothing for output tokens.
Each request can include 400 questions. Inputs can contain text, images, or native JSON.
The API also supports US and EU processing. Eligible customers can request Zero Data Retention.
Real users show why bounded decisions matter.
Box reported about five times faster routing across 30 insurance certificate cases. Low-confidence cases went to human reviewers.
Datadog uses the API to score risky agent-generated shell commands. Datadog reported 40 times faster p95 performance with similar accuracy.
Sierra uses it to pick actions during customer conversations. Sierra reported under 280 milliseconds p95 and 90% lower cost per call.
These are classification, routing, and risk decisions placed before an action.
That's where the OpenAI Decisions API belongs.
For computer work, another model can handle execution. OpenAI prices GPT-6.1 Terra at $1 per million input tokens and $5 per million output tokens.
The decision model chooses the lane. The action model works within it.
Your Week-One SOW Should Look Like This
A serious statement of work needs a seven-day build plan.
"Discovery and AI strategy" without working software is calendar filler.
Day 1: Pick one measurable workflow
Choose one repeated decision with a clear outcome.
Good starting points include:
- Route an inbound lead
- Score account fit
- Approve an email draft
- Classify a support ticket
- Escalate a pricing request
- Flag risky campaign claims
Define the current time, cost, error rate, and human workload.
Day 2: Write the decision contract
List every allowed answer.
For inbound leads, that might be:
- `sales`
- `nurture`
- `support`
- `reject`
- `human_review`
Set confidence rules. A score below 0.85 might require review.
That threshold is a business policy. Keep it out of the prompt.
Day 3: Create least-privilege tool access
Give the agent only the permissions required for this workflow.
A HubSpot sales agent might receive:
- Read access to selected contact fields
- Permission to create tasks
- Permission to update one qualification field
- No delete permission
- No bulk export permission
- No billing access
An email agent might draft messages without sending them.
A marketing agent might create campaigns without publishing them.
Use separate credentials for each agent. Never share an administrator account.
Day 4: Add replayable traces
Every run needs a unique `trace_id`.
Record these fields:
| Field | What it proves |
|---|---|
| `trace_id` | Which run is under review |
| `timestamp` | When the action happened |
| `input_hash` | Which input the agent received |
| `prompt_version` | Which instructions were active |
| `model` | Which model made the call |
| `decision` | Which bounded answer won |
| `confidence` | Why automation continued |
| `policy_version` | Which rules applied |
| `tool_name` | Which system was called |
| `tool_arguments` | What the agent attempted |
| `authorization_result` | Whether access was allowed |
| `human_approval` | Who approved sensitive work |
| `cost` | What the run cost |
| `final_state` | What changed |
Mask sensitive values. Make the record append-only.
We use n8n for orchestration, not Zapier. PostgreSQL works well for trace metadata.
Store large payloads in object storage. The trace should point to their hashes.
Replay doesn't mean the model returns identical wording. It means you can reconstruct the run.
Days 5 through 7: Test, break, and launch narrowly
Run real historical cases through the full system.
Don't test only happy paths.
Include duplicates, empty fields, prompt injections, expired offers, and unavailable tools. Test revoked credentials and API timeouts.
Launch to a small group first. Keep a kill switch available.
Week one should end with working software.
These Acceptance Tests Should Be in the Contract
Consultants love vague promises because vague promises can't fail acceptance testing.
Fix that in the contract.
Require these tests before launch:
- 100% of tool calls contain a valid `trace_id`
- 100% of low-confidence decisions enter review
- Zero out-of-scope tool writes succeed
- Revoked credentials stop access immediately
- Failed validation blocks the next action
- Duplicate requests don't create duplicate records
- Every prompt change receives a version number
- Every policy change receives a version number
- Sensitive fields are masked in stored traces
- The system can replay a failed run
- A human can stop the agent without code changes
Add an evaluation set with at least 50 representative cases.
Agree on accuracy by decision type. Don't hide everything inside one average.
Lead routing might require 95% accuracy. Compliance checks might require human review below 99%.
These are proposed thresholds. Your risk level determines the number.
Your contract should also name the response process.
Use language like this:
> The vendor will preserve replayable traces for every action. Any unauthorized write pauses the affected workflow until review.
Add model-change protection:
> Model or prompt changes require regression testing against the approved evaluation set.
Add an access rule:
> Each agent receives separate credentials and the minimum required permissions.
Add an ownership rule:
> The customer owns prompts, policies, traces, workflow code, and evaluation cases.
If a consultant refuses those terms, they're selling dependence instead of accountable AI agent consulting.
ROI Comes From Completed Work, Not Token Prices
The Decisions API is cheap. Human review and bad architecture aren't.
Measure completed work that remains correct and authorized.
Use this monthly formula:
> Value = labor saved + added gross profit − model costs − tool costs − review costs − support costs
Don't count every automated step as a win.
Count accepted outputs. Count qualified meetings. Count resolved tickets.
Asana offers a useful benchmark.
Its Workato-based sales engine cut research from 10 hours weekly to one hour. It also produced 2.3 times the prior email reply rate.
Asana reported a 10% bookings increase during the first quarter. Each generated deliverable cost about $0.10.
The controls matter as much as the results.
Asana used source attribution, read-only MCP access, and limited fields. Its agent could draft outreach but couldn't send it.
L'Oréal followed the same pattern with Salesforce Agentforce.
Case handling dropped from about seven minutes to 2.5 minutes. Promo code creation dropped from roughly 10 minutes to one minute.
Advisors still reviewed messages. L'Oréal also mapped the exact data each agent could access.
OpenRouter reported 600 hours saved monthly with its Rasp sales agent. Costs fell from nearly $800 daily to about $30.
Rasp routes sensitive decisions to people. Humans still handle calls, negotiations, and relationships.
Useful agents remove repeated work while keeping human authority in place.
StoryPros builds AI automation for sales and marketing around that principle. The goal is completed work you can trust.
FAQ
Are AI agents a waste of time?
AI agents work when they own a narrow, measurable workflow. Asana cut weekly account research from 10 hours to one and reported 10% more bookings.
They become wasteful when consultants skip permissions, testing, and trace records. A prompt without controls isn't a production agent.
What is required to build an AI system?
A working AI system needs approved data, a decision layer, limited tool access, validation, and replayable traces. It also needs evaluation cases and a human review path.
The model is only one part of the system. OpenAI's Decisions API handles bounded choices, while your application controls the action.
Why do AI agents fail in most companies?
AI agents fail when teams start with a model instead of a business decision. Teams also fail when they grant broad access and skip regression testing.
V1 usually reaches 60% to 70% of the target. Feedback, traces, and repeated testing close the gap.
What should AI agent consulting deliver in Week 1?
AI agent consulting should deliver one working workflow within seven days. That workflow should include bounded decisions, least-privilege access, replayable traces, tests, and a kill switch.
A strategy deck doesn't meet that standard.
How much does the OpenAI Decisions API cost?
OpenAI prices the Decisions API at $0.10 per million input tokens. Cached input costs $0.01 per million tokens, with no output-token charge.
The larger cost usually comes from human review, integrations, and poor workflow design.
Related Reading
What should AI agent consulting deliver in the first week?
A working control layer with bounded decisions, least-privilege tool access, and replayable traces by Day 7. Every run needs a unique trace_id, a confidence threshold, and a kill switch. Strategy decks and prompt templates do not meet that standard.
How much does the OpenAI Decisions API cost?
OpenAI prices it at $0.10 per million input tokens. Cached input costs $0.01 per million tokens, with no charge for output tokens. Each request supports up to 400 questions and accepts text, images, or native JSON.
How fast is the OpenAI Decisions API compared to regular GPT models?
OpenAI says it runs up to 10 times faster than GPT-6 Luna through Responses. Sierra reported p95 latency under 280 milliseconds and 90% lower cost per call. Datadog reported 40 times faster p95 performance at similar accuracy.