Editor's note: This guide draws on roughly 1,000 Agentforce readiness scans Clientell has run on production Salesforce orgs across mid-market and enterprise. Industry benchmark numbers (38 / 71 / 84) and the 70% first-scan failure rate are from that dataset. The checklist below is what we see top-performing teams complete before they commit to an Agentforce rollout budget.
TLDR
- 70% of Salesforce orgs we scan score below 70 on AI Readiness on the first attempt.
- Industry-average score: 38. Top-25% threshold: 71. Top-10%: 84. You need at least 70 before Agentforce ships without surprises.
- Four dimensions decide readiness: Data Quality (30% weight), Process Clarity (25%), Permission Hygiene (20%), Automation Overlap (25%).
- Automation Overlap is the #1 AI killer in our scoring engine. Competing Flows, legacy Workflow Rules, and Apex triggers firing on the same object are the single biggest predictor of failed rollouts.
- The checklist below is 47 items, organized by dimension. Roughly 1 full day per dimension if you do it manually. About 10 minutes total if you run our free readiness audit.
The 70% problem
If you sit down to read three Agentforce post-mortems in a row, you will hear the same story.
Someone, usually a CIO, committed to a launch date. A team got assigned. Licenses were bought, partners were hired, agents were configured. Then the agents went live and started hallucinating answers, routing the wrong leads, inheriting admin-level permissions they should not have had, or quietly failing to act because the data they needed was empty on more than half the records they touched.
The pattern is so consistent that we treat it as a single category of failure rather than ten separate ones. The platform itself works. Agentforce is a real product, with a real reasoning engine, and real customers shipping production agents. The gap is between the org and the agent. The agent is only as good as the substrate it runs on. And for most Salesforce orgs in 2026, that substrate is not ready.
This is why we built the Agentforce Readiness Audit as a free product. The audit takes 10 minutes, returns a 0–100 score, and benchmarks you against the industry. Then it ships a 24-hour fix plan with one-click sandbox-tested fixes for every blocker. Most teams gain 20–30 points in the first 24 hours after the scan finishes.
The rest of this post is the checklist itself. Run it yourself or run it through the audit. Either way, do not commit to an Agentforce rollout date until you have it cleared.
What "Agentforce readiness" actually means
A common misconception: "readiness" means having Agentforce licenses, Data Cloud provisioned, and a use case picked. Those are prerequisites for the project, not for the agent. The agent's readiness lives one layer down, in the state of the Salesforce org itself.
Specifically, in four dimensions:
| Dimension | Weight | What it measures |
|---|---|---|
| Data Quality | 30% | Field completeness, duplicate density, required-field gaps on agent-touched objects |
| Process Clarity | 25% | Defined stage criteria, low rework rate, documented ownership of every flow |
| Permission Hygiene | 20% | Profile consolidation, scoped runtime user, least-privilege integration users |
| Automation Overlap | 25% | No competing automations on the same object, no legacy Workflow Rules firing alongside Flows |
These weights match our scoring engine in production. The combined score is what we call the AI Readiness Score.
The benchmarks you should know
These numbers come from roughly 1,000 production scans we have run between 2024 and 2026:
- Industry average: 38 out of 100
- Top-25% threshold: 71 (the bar most teams should aim for)
- Top-10% threshold: 84 (orgs that ship Agentforce with zero remediation surprises)
The first time you scan an org, the most likely outcome is a score between 35 and 55. That is normal. It is also the gap that needs to close before launch.
The 47-point checklist
Organized by dimension, ordered by impact within each. Each item is something we measure directly in the readiness audit. You can also work through these manually if you have the time, but the order of operations matters.
Dimension 1: Data Quality (30% weight)
This is the largest weight because it is the single biggest determinant of whether the agent's outputs are accurate. An agent reading empty fields hallucinates the missing values rather than asking.
- Lead.Rating completeness above 70%. We see this empty on 55% of records as the median. Below 70%, lead routing agents stop working reliably.
- Account.Industry completeness above 80%. Territory and routing logic depends on this. Blank on 31% of accounts is the median pattern.
- Opportunity.NextStep populated on all open Opportunities. Pipeline analysis agents depend on this string.
- Contact.Email validated and unique. Email agents misbehave with malformed or duplicate emails.
- Required fields enforced via validation rule, not just page layout. Layout-only requirements bypass via API.
- No more than 2% duplicate Contacts. Above 2%, agents start picking the wrong record to act on.
- No more than 2% duplicate Accounts. Same risk on the parent record.
- Field utilization above 60% for every agent-touched custom field. Below 60% means the field is functionally dead.
- Picklist values cleaned and standardized. No "Closed Won" vs "ClosedWon" vs "closed_won".
- No more than 10% stale records (created or modified > 18 months ago without any updates).
- Data Cloud grounding fields populated. If you are using Data Cloud, fields the agent grounds on must be > 90% complete.
- No orphan records (Contacts without AccountId, Cases without ContactId, etc).
Dimension 2: Process Clarity (25% weight)
A process that humans navigate ambiguously is one an agent cannot navigate at all. Agents follow rules; if the rule is "do whatever feels right in the moment", you do not have a rule.
- Every Opportunity stage has explicit entry criteria. Documented, not "the AE knows".
- Every Opportunity stage has explicit exit criteria.
- Stage skip rate below 15%. If 31% of deals skip Needs Analysis (a common pattern), the agent learns "skip is fine" and reinforces it.
- Rework rate below 20%. Loop-backs from later stages to earlier ones confuse the agent's pipeline forecasting.
- Documented owner for every active Flow. Not "Admin". A named person.
- Documented purpose for every active Flow. A one-sentence description of what it does and why.
- Lead Qualification has a single defined entry point. Not "wherever the rep wants".
- Renewal process has a clear handoff from Sales to Success. Agents working renewals need the handoff trigger.
- Case escalation criteria documented and enforced. Support agents need an unambiguous escalation rule.
- No undocumented flow exceptions. "Except when the customer is enterprise, then we route differently" must be in the flow, not in someone's head.
Dimension 3: Permission Hygiene (20% weight)
Most orgs fail this dimension on the first scan. The risk is concrete: the agent inherits whatever permissions its runtime user has. If that user can read everything and write to most things, the agent will too.
- Profile count below 25. Profile sprawl correlates almost perfectly with permission leakage.
- No more than 2 Integration Users with System Administrator profile. Most orgs have 4+. Most should have 0.
- Agent runtime user has a least-privilege custom profile. Not "Standard User", not "System Administrator".
- Permission sets used in place of profiles for one-off access. Profiles for the baseline; permission sets for everything else.
- No more than 5 stale permission sets (no users assigned in 12+ months).
- No inactive users consuming licenses. 62 inactive users still licensed is the median we see.
- MFA enforced on all human users.
- API access scoped per integration user. Each integration has its own user with its own permissions.
- Connected apps reviewed in the last 12 months. Surface area of OAuth integrations matters.
- Apex classes that bypass sharing (
without sharing) reviewed and justified. Each one is a permission shortcut. - Sensitive fields (PII, financial) flagged and access-restricted. The agent should not see what it does not need.
Dimension 4: Automation Overlap (25% weight)
This is the #1 AI killer in our scoring engine. An agent cannot operate cleanly on top of conflicting automation. The downstream effect is the agent appearing to make decisions that are actually being overwritten by a hidden trigger 200ms later.
- No more than 5 active Flows on a single object. Above this number, race conditions become statistically likely. 14 on Opportunity is the median we see. Far too many.
- No Workflow Rules firing on objects that also have active Flows. Pick one mechanism per object.
- No Process Builder processes still active. Legacy automation; migrate to Flow.
- Apex triggers do not duplicate Flow logic. If a Flow updates a field on save and a trigger updates the same field on save, you have a race condition.
- One trigger per object (the "one trigger framework" pattern). Multiple triggers on the same object compound the race risk.
- Validation rules execute before Flows that depend on them. Order matters.
- No flows in "Draft" status that should have been activated. Or activated and forgotten.
- Subflow call depth below 4. Deep subflow nesting is hard for the agent to reason about.
- No silent Flow failures in the last 30 days. Check the Flow error logs. If failures are being swallowed, the agent inherits inconsistent data.
- Apex governor limit headroom above 30% on all triggered automation. Agents push automation harder than humans do.
- No hardcoded IDs in Apex referenced by automation. They break in sandbox refresh and the agent fails silently.
- No SOQL queries in for-loops (
has_soql_in_loop). This is a governor limit risk pattern our engine specifically flags. - No DML in for-loops (
has_dml_in_loop). Same risk category. - All flow paths tested via Apex unit test or sandbox dry-run. The agent needs deterministic flow behavior to build on.
Where most orgs fail
A typical first-scan profile, drawn from our median data:
- Data Quality: 42/100
- Process Clarity: 58/100
- Permission Hygiene: 31/100 (worst dimension)
- Automation Overlap: 47/100
- Aggregate: 47/100
Roughly 62% of the open blockers we surface live in Permission Hygiene and Automation Overlap. These are also the two dimensions where the fix path is most concrete. We see most orgs gain 20–30 points by closing the top 8 to 12 of these specific blockers, which is the work that fits into a one-week sprint.
The Data Quality dimension gains slower because data fixes require validation-rule design plus a dedupe pass plus required-field enforcement, and those can take 2-3 sprints to land cleanly. Process Clarity gains slowest because it requires stakeholder alignment on stage definitions, not just config changes.
The 5-day prep timeline
If you have a board mandate to ship Agentforce in 60 days and your current score is below 70, this is the pragmatic prep timeline:
Day 1, scan and decide. Run the readiness audit. Read the score. Decide whether to proceed on schedule, push the date back, or descope to a single use case in a single department.
Day 2, triage Permissions first. This dimension gains the fastest. Consolidate profiles. Scope a least-privilege runtime user for the agent. Retire 4+ Integration Users with admin access.
Day 3, triage Automation Overlap. The #1 AI killer. Map every active Flow on the top 3 agent-touched objects. Identify race conditions. Retire legacy Workflow Rules.
Day 4, triage Data Quality. Validation rules on the top 5 critical fields. Dedupe pass on Contacts and Accounts. Required-field enforcement on Lead.Rating and Account.Industry.
Day 5, re-scan and validate. Run a fresh scan. Confirm the score lifted. QA the changes in sandbox. Promote to production via deployment.
Most teams who run this five-day prep arrive at score 70+ by Friday, which is the minimum for a smooth Agentforce launch. Teams who skip this prep arrive at the launch date and discover the same blockers mid-deployment, which is more expensive and slower to fix.
Tools comparison: how to score readiness
There are four ways to score Agentforce readiness in 2026. Each has tradeoffs.
| Tool | Format | Cost | Benchmarks? | Ships fixes? |
|---|---|---|---|---|
| Salesforce Optimizer | Static PDF | Free | No | No |
| Hubbl Diagnostics | Audit report | $$ | Partial | No |
| Elements.cloud | Dependency graph | $$ | No | No |
| Consulting partner | Manual review | $$$ ($15K–$40K) | Sometimes | Recommendations only |
| Clientell Readiness Audit | Live scoring + fix plan | Free | Yes (1,000+ orgs) | Yes (one-click sandbox) |
The honest framing: every tool above is useful for something. Salesforce Optimizer is fine for surfacing the most obvious config issues. Hubbl is excellent for static documentation. Elements.cloud is the best dependency mapper if that is your primary need. Consulting partners are appropriate when you want a human delivering the report to your board.
What none of them do is score readiness specifically for Agentforce, benchmark against a peer dataset, and ship a fix per blocker that you can apply in sandbox with one click. That gap is the reason we built our audit and continue to make it free.
The cost of getting this wrong
Agentforce TCO is widely understated at sign-up. Here is the honest math for a 100-person org:
- Agentforce licenses: ~$2/conversation or Flex Credits at $0.10/action. For a moderately active customer-service deployment, this lands around $66K/year minimum.
- Data Cloud: Required for production grounding. Roughly $500 per 100k credits. We have seen orgs blow through their Data Cloud projection by 400% in the first quarter because nobody modeled the action volume.
- Implementation: $50K–$150K from a Big-4 partner. Sometimes more.
- Remediation if the org is not ready: This is the hidden cost. If your readiness score is 47, you will spend roughly 4-8 weeks of senior architect time fixing blockers mid-project. That cost rarely shows up in the original budget and is the most common reason Agentforce projects miss their launch dates.
A readiness audit before commitment closes the last cost category before it appears. The audit itself is free. The hour of CIO time to read the score is well spent.
Run the audit
The 47-point checklist above is what we measure in the free Agentforce Readiness Audit. You can do it manually, or you can let the agent score it in 10 minutes.
If you want the workflow that takes a 41 score to 78 in seven days, that day-by-day playbook lives at How efficient Salesforce teams audit their org in 7 days.
If your readiness score comes back below 50 and you are wondering whether Agentforce is even the right tool for your team, 8 Agentforce alternatives in 2026 is the honest list.
If you are past the audit stage and need help fixing the blockers, AI Salesforce Admin is the agent that does the work in your org, and AI Salesforce Deployments is how the fixes ship from sandbox to production.
FAQ
What is a good Agentforce readiness score? Above 70 out of 100. Industry average is 38, top-25% is 71, top-10% is 84. Above 70 is the minimum for a smooth deployment without mid-project remediation surprises.
How long does the readiness audit take? Roughly 10 minutes for the scan. The full 24-hour fix plan, with prioritized blockers and one-click sandbox-tested fixes, ships within a day.
Is the Clientell audit really free? Yes. Scan, score, diagnostic PDF, executive deck for the board, and remediation backlog are all free with no paid engagement.
Does Agentforce require Data Cloud? For most production use cases, yes. Data Cloud is where Agentforce stores grounding data and where Flex Credits accumulate. Our report includes a Data Cloud cost projection based on your actual record volumes.
What permissions does the scan need? A read-only OAuth user with API access. We do not write to your org during the scan. You can revoke the connection at any time.
Can I run the audit on sandbox first? Yes. Many teams run their first scan on a partial-copy sandbox so they can compare it against production later. A production scan has no write surface, but starting on sandbox is the conservative choice.
What if my score comes back below 50? Pause the Agentforce launch by 30-60 days. Run the 5-day prep timeline above. Re-scan. Most orgs lift their score by 20-30 points in the first week if they prioritize the top 8 blockers.
Is the 47-point checklist exhaustive? It is the working subset we have found predicts readiness reliably. Our scoring engine measures roughly 80 individual checks in total, but the 47 above are the ones whose status moves the score the most. The full engine output is in the audit report.
