Imagine an assistant that reads opportunities, updates contacts, and replies from Slack or WhatsApp. Today, in many orgs, that assistant operates with the same identity as the person it helps.
If something goes wrong, the trail points to the human, not the agent. That is about to change.
At TDX, Salesforce presented the idea behind AIforce (then called Headless 360). The promise is to bring the platform's context to the surface where you already work, without forcing you into the browser.
The Headless Toolkit is the piece that turns that idea into a usable product. With both comes a new requirement.
You will have to register every agent that interacts with Salesforce. That registration is not a cosmetic formality.
It is the same lever that gives the agent identity, governance, and billing. If you are already exploring AI agents or have integrations built on Salesforce, this announcement hits close to home.
It is worth understanding before the formal notice for Agentic Identity starts the clock on deadlines.
The problem with lending your credentials to the agent
Until now, many external agents connect with OAuth or API keys tied to a user. The agent inherits the permissions of that person.
It can see the same things, write the same things, and, in the worst case, break the same things. That creates three clear points of friction.
First, confusing audits: you can't tell whether María made the change or the bot that assists her. Second, excess permissions: the agent usually gets a broad permission set designed for humans.
Third, invisible consumption: agentic traffic gets mixed in with classic integration traffic. There is no clean category to measure it.
Agentic Identity aims to break that habit. Instead of lending someone's credentials, you issue the agent its own.
It is like giving it its own access badge, not the one from the employee next door.
What AIforce is (and what it is not)
AIforce is the concept. It is about bringing Customer 360 context to the interface where you already are: an IDE, a chat, a portal, or a messaging channel.
It does not force you to live inside the Salesforce browser for the agent to do its job. It is not a standalone product with a magic button.
It is the framework that explains why Salesforce is investing in APIs, protocols, and controls built for agents that live outside the classic UI.
If you want to see how this translates into real implementations, at Vantegrate we work right at that frontier. Agents that converse, sell, and operate without the user opening another tab.
Headless Toolkit: the piece that makes it real
The Headless Toolkit is the functionality. It lets an agent build, act, and deliver results without the Salesforce UI in the middle.
It speaks MCP (Model Context Protocol) and direct APIs. It speaks to external surfaces.
Around November, Salesforce plans to release a concrete package around that toolkit. It includes security controls, agentic registration, and a new billing model.
The three come together on purpose. The same registration step that creates the agent's identity is the one that makes it visible, governable, and billable.
There is no security form on one side and a cost form on the other. It is a single lever.
Why registration matters more than the announcement's marketing
Registering an agent in the Platform means an admin creates a discrete identity for that agent. It stops operating under the identity of the human it assists.
On that identity you can attach a narrower permission set. Fewer objects, fewer fields, and fewer actions.
The agent gets only what it needs for its job. Not the full menu of a sales or service user.
That is real security, not a checklist. If your security policy calls for least privilege, Agentic Identity is the way to apply it to bots, not just people.
It also improves data transparency. When every agent has its own name in the Platform, you can answer clearly who touched what, when, and with what scope.
Security and billing: the same lever
It is tempting to read the announcement as two separate pieces of news: one about compliance and one about pricing. They are not.
Without registration, Salesforce cannot attribute agentic traffic precisely. Without attribution, there is no fine-grained governance and no clean metering.
That is why registration opens both doors at the same time. For you, as an admin or tech leader, the practical message is simple.
If you are going to keep using agents that call Salesforce, plan the registration as a project. Not as a click on the last day.
Headless Platform Interaction (HPI): the new unit
Once the agent is registered, its usage can be tracked in Digital Wallet. That is where Flex Credits come in.
Salesforce added a new usage type within the Customer 360 Platform category of the Flex Credits Rate Card. That type measures the calls a registered agent makes to the platform through AIforce and the Headless Toolkit.
Each successful call counts as one Headless Platform Interaction (HPI). It does not matter whether it arrives through MCP or a direct API.
If the registered agent talks to Salesforce and the call completes successfully, that is an HPI. The multipliers for that usage type are not yet published.
They appear as TBA and, for now, agentic usage will not be metered. Salesforce promises 30 days of notice before setting a number and starting to charge in credits.
In the meantime, it makes sense to watch the Rate Card and follow closely when the cost of an HPI appears. If your org already looks carefully at agentic product pricing, this new line item deserves a row in your cost spreadsheet.
What changes if your org is new or already existing
The deadlines are not the same for everyone.
If you buy on or after the publication date of the announcement, you will have to register every agent that uses Salesforce APIs. The deadline is three months from the notice that Agentic Identity is available.
If you are already a customer and use agents with APIs, the key moment is the renewal. That is when you will be asked to register agents and migrate those connections to the new billing model.
There is one cross-cutting case. Using any Salesforce MCP server requires agent registration within three months of the notice, for all customers.
It does not matter whether you are new or long-standing. MCP is not a shortcut to avoid Agentic Identity.
In fact, it is the channel where the requirement arrives earliest and most evenly.
Free sandbox, metered production
There is good news for builders. HPIs are consumed in active production orgs, once the Rate Card has numbers and the agent is registered.
Sandboxes, scratch orgs and Developer Edition do not generate HPI metering in Digital Wallet. You can build, break and test without burning Flex Credits on rehearsals.
The credits seeded in the org cover the deployment to production and testing in that environment. The message is clear: experiment cheaply, measure seriously once traffic is real.
Traditional integrations do not change in price or controls because of this announcement. The model targets agentic traffic.
Your footprint of classic integrations stays as it is today.
Practical steps once Agentic Identity is available
When the notice arrives, the suggested path is short and orderly.
One. Make sure your org is enabled for billing with Flex Credits. That means Salesforce Foundations (currently available at $0) or another SKU that activates Flex Credits in the org.
Two. Register each agent with Agentic Identity. That is where the discrete identity and the scoped permission set you want it to operate with are created.
Three. Reconfigure your MCP clients (and the agents that use APIs) to present the registered agent's new OAuth credentials. That step is what lets Salesforce classify the connected app as an agent.
Four. Reconnect the agent and keep using it. Functional behavior should feel the same.
What changes is the trail: every successful interaction is recorded as an HPI against your Flex Credits. If your development team lives in APIs and headless tools, also check the Salesforce guide for developers.
The OAuth identity change is not just an admin task. It touches clients, secrets and credential rotation.
How to think about it in a mid-sized LATAM company
Suppose you have an agent that qualifies leads over WhatsApp and writes to Salesforce. Today it runs under the sales integration user.
Tomorrow, that agent needs its own identity, with permissions only on Leads, Campaigns and maybe Tasks. Another example: a BI agent that queries metrics and builds summaries.
If you use something like Metrix, the right pattern will be the same. Its own identity, a scoped reach, visible consumption.
The risk is not only technical. It is a governance risk.
Without registration, an agent with excess permissions can read or write more than it should. With registration, the admin sets the ceiling before the bot requests its first token.
If you want to see what this looks like in a concrete demo, you can schedule a demo and walk through the flow with a case from your industry.
What you should review this week (without waiting for November)
Agentic Identity does not need to be live for you to start putting your house in order.
Build an agent inventory. List every bot, script or MCP client that touches Salesforce.
Note which user or connected app each one uses today. Mark which ones live in production and which only in a sandbox.
Future metering is concentrated in production. Registration will also ask you for clarity on what is truly live.
Review permission sets. Ask yourself, agent by agent: does this bot need to delete records, or only create and update them?
Does it need to see sensitive fields, or only stage and amount? Document owners.
Every agent should have a responsible human. When registration arrives, that person is the one who defends the scope and the credit budget.
In Pulse and in the Vantegrate resources you will find more pieces on agents, security and implementation. Add it to your reading folder before the formal notice.
Common mistakes to avoid
First: waiting for the renewal without taking inventory. If you are an existing customer, the formal deadline may fall at renewal, but migrating connected apps and OAuth is not a Friday afternoon job.
Second: registering the agent and leaving it the same broad permission set as the human user. You meet the identity requirement and fail the least-privilege one.
Third: testing HPIs only in production. Use sandbox and scratch orgs to validate the flow.
Production should be the place where you measure, not where you discover that the MCP client was signed incorrectly.
Fourth: mixing classic integrations with agentic traffic in the same connected app. The announcement leaves traditional integrations untouched.
Take advantage of that boundary. Separate identities.
The role of the partner and the internal team
This change is not only about architecture. It is about team capabilities.
Someone has to understand Flex Credits, Digital Wallet and the Rate Card. Someone has to rotate OAuth without taking down the sales bot on a Monday at 9.
If your org is small, that someone can be the same person who administers Salesforce and who programs the agent. If it is larger, set up a clear routine among admin, security and development.
At Vantegrate we explain how we support cutovers like this. Not just the registration click, but the design of permissions, the inventory and the cost conversation with the business.
A simple way to explain it to your CFO
Your CFO doesn't need MCP or Headless Toolkit. They need three sentences.
One: agents will have their own identity in Salesforce. Two: every successful call to the platform will be able to consume Flex Credits (once the multiplier stops being TBA).
Three: sandboxes don't burn HPI credits; production does. That's enough to ask for a Foundations budget (if you don't have one yet), admin time and a credit buffer for the ramp-up in the first months after metering starts.
What doesn't change (and why it matters)
The price and the security model of traditional integrations don't change. If you have a middleware today that syncs orders without being an agent, this announcement doesn't rewrite that bill.
The value of building in a sandbox doesn't change. On the contrary: it reinforces it.
Rehearsal is still the cheap place to learn. It also doesn't change the fact that a poorly designed agent is still a risk.
Agentic Identity gives you the framework. The quality of the prompt, the tool calling and the flow design is still yours.
Practical wrap-up (no speeches)
AIforce provides the concept. Headless Toolkit provides the machinery.
Agentic Identity and Flex Credits set the rules of the game: identity, permissions and measurement. Controls, registration and billing arrive around November.
The HPI multipliers are still TBA, with 30 days' notice before real metering. Registration deadlines depend on whether you are a new buyer, a customer in renewal or an MCP user.
Your best move now is to inventory agents, shrink permission sets and decide who owns each bot. When the notice arrives, the path is Foundations or a Flex Credits SKU, registration, new OAuth and reconnection.
If you want to turn this into a 30-day plan for your org, request a demo. The announcement is already out.
The preparation time is whatever you have left.
