The Agentforce license doesn’t make an org ready; the org makes the agent trustworthy. An agent inherits the estate exactly as it is — automation quirks, identity fragmentation, access sprawl — and amplifies whatever it finds. The readiness work is ordinary org work; the agent is why it finally gets funded.
The four prerequisites, in order of leverage
1. Automation on one engine. Agent actions compose with Flow. Logic still living in Workflow Rules and Process Builder is behavior the agent can trip over and you cannot easily extend. Migrate per object so save order survives.
2. Identity the agent can be grounded on. The same customer under three Accounts means the agent answers confidently from whichever record it hits — the failure mode that looks like success. Duplicate and matching rules on core objects come before any grounding conversation.
3. Access as the agent’s specification. The agent acts through a user context; whatever that context can reach, the agent can be induced to touch. Least privilege stops being hygiene and becomes the operating envelope.
4. Platform currency. Components below the API retirement line and UI still leaning on Aura and Visualforce decide whether the org can adopt agent capability on Salesforce’s cadence rather than its own backlog’s.
All four are measurable today — Horus Eye measures them as findings, with fix paths, rather than as an invented readiness score. And once the runway is cleared, the agent conversation starts from evidence.
A pre-agent readiness pass, concretely
Scope it to the objects the agent will actually read and write — readiness is not a whole-org virtue. On those objects: data quality first, because an agent grounded in stale or duplicated records will answer confidently from them; then permissions, because the agent’s user context defines its blast radius and inherited Modify All is a bigger risk in an autonomous actor than in a person; then automation, because an agent’s writes trigger the same flows and triggers as everyone else’s, and an overlapping-flow problem becomes an agent-loop problem. Knowledge sources deserve the same scrutiny: an article that was wrong but harmless in search results becomes wrong at conversational scale.
Decide what “working” means before go-live
Write down, in advance, the handful of conversations the agent must handle and the field states each should produce — then test those as literally as you would test a deployment. Teams that skip this discover their acceptance criteria in production, one escalation at a time. The point of fixing the foundation first is not perfection; it is knowing which failures are the agent’s and which were waiting in the org all along.
The bottom line
Agent programs do not fail at the model; they fail at the org underneath it. The encouraging corollary: the fixes are ordinary admin work — data hygiene, scoped permissions, untangled automation — done with a deadline and a purpose. Teams that run that pass first ship agents that behave on day one, and know exactly which incidents are new rather than inherited.
