Agentforce vs Copilot Studio vs Vertex Agent Builder

The platform is decided by where your system of record already sits, because integration cost dwarfs feature differences. All three vendors can plan multi-step tasks, call tools, ground answers in your documents, and hand off to a human. What they cannot do is change where your data lives, and that is the variable that dominates total cost of ownership.

Here is why features are a trap. Every enterprise agent RFP turns into a checklist of capabilities that all three vendors tick. Multi-agent orchestration, retrieval, guardrails, analytics, voice: parity, parity, parity. Meanwhile the line item that quietly triples the project budget never appears on the checklist, which is the connector you build and maintain to reach data the platform does not natively see. A Salesforce-native agent answering a Salesforce question needs no connector. The same agent answering a question whose data lives in SharePoint needs one, and now you own an integration forever.

So the useful question is not "which platform is smartest" but "which platform sits on top of the data my highest-value agents need." That reframes the entire comparison. If your customer records, cases, and pipeline live in Salesforce, Agentforce starts every task with the data already in hand. If your documents, email, and collaboration live in Microsoft 365, Copilot Studio does. If your analytics and custom applications live in Google Cloud, Vertex does. The build-versus-buy calculus shifts accordingly, and our guide on when to build versus buy an AI system is the right companion when the answer is not obvious. The pillar overview of enterprise AI agent architecture maps where these no-code platforms sit relative to the developer frameworks below them.

Agentforce is the right pick when your system of record is Salesforce, and it prices customer-facing agents at $2 per conversation or bills usage in Flex Credits. It is the CRM-native option, built on the Atlas Reasoning Engine, Salesforce's orchestration layer that plans an agent's steps and reads and writes Sales Cloud, Service Cloud, and Data Cloud without a connector in between.

That native reach is the entire value proposition. An Agentforce agent resolving a support case already has the account, the case history, the entitlements, and the knowledge base in scope, because they all live in the same platform. According to Salesforce Ben's 2026 pricing guide, Agentforce bills customer-facing agents at $2 per conversation under its Conversations model and bills usage-based work through Flex Credits at $500 per 100,000 credits, or half a cent each. A standard Agentforce action consumes 20 Flex Credits ($0.10), and a voice action consumes 30 ($0.15).

Pricing has more than one door, which matters for how you pilot. Salesforce Foundations lets Enterprise Edition and above add core Agentforce features to existing CRM at $0, which is the cheapest way to prove value before committing budget. At the other end, Agentforce 1 editions start at $550 per user per month and bundle add-ons plus 2.5 million Flex Credits per year, while the standalone Agentforce User License is $5 per user per month with Flex Credits purchased separately. Employee-facing add-ons run $125 per user per month for Sales, Service, and Field Service, and $150 for Industries. The through-line: Agentforce earns its keep when Salesforce is where the work already happens, and it gets expensive fast when you try to make it the front end for data it does not own.

Copilot Studio is the right pick when your data lives in Microsoft 365, and it bills consumption in Copilot Credits at $200 per 25,000 credits. A Copilot Credit is Microsoft's consumption unit for agent activity: every answer, action, and grounding call spends a fixed number of credits, and you buy them in prepaid packs.

The data-gravity story mirrors Salesforce, pointed at the other giant. A Copilot Studio agent grounds natively in SharePoint, Teams, Outlook, OneDrive, and Dynamics, so a company that runs on Microsoft 365 gets the same connector-free advantage Agentforce gives a Salesforce shop. According to Microsoft's Copilot Studio licensing guide (2026), one Copilot Credit pack costs $200 per month, billed annually, and includes 25,000 credits that do not roll over month to month. Once prepaid packs are exhausted, pay-as-you-go overage is metered at $0.01 per credit. Notably, building and managing agents carries no per-builder seat cost: the Copilot Studio User License is $0, so your only bill is consumption.

Consumption is priced per activity, and the rates decide your real cost. According to Microsoft's message and credit management documentation (2026), a classic answer consumes 1 credit, a generative answer 2, an agent action 5, tenant graph grounding 10, and premium generative AI tools 10 credits per 1,000 tokens for reasoning models. Two operational gotchas belong in your model. Credits do not roll over, so under-provisioning wastes money and over-provisioning wastes more. And Microsoft disables custom agents once a tenant reaches 125% of its prepaid capacity, so a viral internal agent can hit a hard stop mid-month if you have not sized the pack.

Vertex AI Agent Builder is the right pick when you are GCP-native and have engineers, and it prices usage per token rather than per conversation or per credit. Vertex AI Agent Builder is Google Cloud's toolkit for building and deploying agents, and Vertex AI Agent Engine is the managed runtime that hosts them. Unlike Agentforce and Copilot Studio, it is a developer platform: agents are built, deployed, and maintained by engineering, not clicked together in a low-code canvas.

The pricing model is fundamentally different, and it is the most transparent of the three at the model layer. You pay for the underlying model per token. According to Google's Gemini API pricing (2026), Gemini 2.5 Flash costs $0.30 per 1M input tokens (text, image, or video) and $2.50 per 1M output tokens including thinking tokens, while Gemini 2.5 Pro runs $1.25 per 1M input tokens for prompts up to 200,000 and $2.50 above that, with output at $10 to $15 per 1M on the same threshold. For high-volume, well-bounded workloads, per-token pricing on Flash is often the cheapest raw unit cost of the three platforms.

The catch is two-sided. First, Vertex AI Agent Engine layers a managed-runtime compute charge, billed by vCPU-hour and memory GiB-hour, on top of the model tokens, so the token price is not the whole bill. Second, and larger, you supply the engineering. There is no free lunch on build effort: someone has to design the agent, wire the tools, deploy to the runtime, and operate it. That is a feature if you want control and a bug if you wanted to ship next week. Vertex is the platform for teams that already live in Google Cloud, need custom orchestration the low-code tools cannot express, and have the people to own it.

To compare Agentforce vs Copilot Studio vs Vertex pricing, convert everything to a cost per unit of real work, then add the build and seat costs the sticker price hides. The list prices are not comparable as published because a conversation, an action, and a token are three different atoms.

Start with a single "standard agent action" and price it in each unit. In Copilot Studio, an agent action is 5 credits: at the prepaid rate of $0.008 per credit that is about $0.04, or $0.05 at the $0.01 pay-as-you-go rate. In Agentforce, a standard action is 20 Flex Credits at $0.005 each, or $0.10, roughly double Copilot Studio per action. In Vertex, there is no fixed per-action price at all; the cost is however many model tokens the action spends (fractions of a cent on Gemini 2.5 Flash for a short turn) plus the runtime compute that action's process consumes. That last term is why you cannot reduce Vertex to a clean per-action number without modeling your own workload.

The unit price is the smaller half of the decision. The larger half is total cost of ownership, and it swings on two things the meters do not show: builder cost and integration cost. Copilot Studio charges nothing for builder seats but bills consumption aggressively and cuts you off at 125% of capacity. Agentforce can be free to start through Foundations but climbs steeply into per-seat editions. Vertex has the lowest model-layer cost and the highest people cost. This is the same tension we unpack in per-seat versus outcome-based pricing models: the headline unit almost never matches where the money actually goes. Model your own action mix and volume against all three meters before you trust any vendor's example math.

All three CRM-native and cloud-native platforms hit the same ceiling: they cannot natively span the SAP, billing, HR, and legacy systems most enterprises actually run. A platform's data-gravity advantage is also its boundary. Agentforce is strongest inside Salesforce and blind outside it. Copilot Studio is strongest inside Microsoft 365 and blind outside it. The moment a high-value workflow needs data from a system the platform does not own, the native advantage evaporates.

This is the failure mode we see most often in deployments we review: a beautifully demoed agent that stalls the first time it needs a purchase order from SAP, an invoice from a billing system, or an employee record from Workday. The fix is always a connector, and a connector is engineering you build, secure, monitor, and maintain. Once you are maintaining three or four of them, the no-code platform is running on a code base you own anyway, and the "no-code" label has quietly become false.

The honest way to size this is to map your target workflows to their systems of record before choosing a platform. If the top five agent use cases all resolve inside one system, a native platform is a clean win. If they span three or more (CRM plus ERP plus a homegrown billing stack), the integration surface is the project, and the platform choice is secondary to how you will bridge those systems. Enterprises consistently underestimate this, because the pilot is chosen for how well it demos, not for how representative it is of the messy cross-system work that follows.

Skip the no-code platforms and build on a developer framework when your agents must orchestrate across many systems of record, need custom logic the low-code tools cannot express, or when no single vendor owns enough of your data to give you a gravity advantage. In that world, the platform's native reach buys you little and its constraints cost you plenty.

A developer framework is a code-first library for composing agents, tools, memory, and control flow, with no assumed system of record. The tradeoff is the mirror image of the no-code platforms: maximum flexibility, and you own everything. You get to integrate SAP, billing, HR, and CRM on equal footing, because the framework has no favorite; you also get to build, host, secure, and operate the whole thing. For teams already comfortable in that world, the framework choice is its own decision. Our comparisons of LangGraph, CrewAI, and the OpenAI Agents SDK, of Google's ADK against AWS Strands Agents, and of Microsoft Agent Framework, Google ADK, and smolagents walk through the leading options and where each fits.

The decision rule is blunt. If one vendor owns 70% or more of the data your agents need, buy that vendor's platform and connect the rest. If your data is genuinely federated across systems no single vendor dominates, the integration work is unavoidable either way, and a framework gives you a cleaner base to build it on than a platform you are constantly fighting to reach outside its walls. Note that Vertex AI Agent Builder already sits close to this camp: it is more build-it-yourself than Agentforce or Copilot Studio, which is why GCP-native teams often treat "Vertex" and "framework" as adjacent choices rather than opposites.

Choose by data gravity first, pricing second, and features last. The platform that sits on your dominant system of record wins on total cost of ownership almost every time, because it eliminates the connector work that quietly dominates these projects. Here is the direct recommendation.

Concretely: use Agentforce if 70% or more of the target data lives in Salesforce, and start on Salesforce Foundations at $0 before you pay for editions. Use Copilot Studio if you run on Microsoft 365, but size your Copilot Credit packs against real per-activity rates and the 125% cutoff, not a vendor estimate. Use Vertex AI Agent Builder if you are GCP-native and have engineers who want per-token economics and full control, accepting the runtime compute charge and the build effort that come with it. Skip all three and reach for a framework when your highest-value workflows span three or more systems no single vendor owns.

Whatever you pick, do the pricing normalization and the systems-of-record map before the contract, not after the pilot. That is exactly the pre-commitment analysis in Particula Tech's build-versus-buy audits: modeling your real action mix against all three meters and mapping your workflows to their data sources, so you sign for the platform your architecture actually favors rather than the one that demoed best.