Agentforce Vibes pricing and licensing

For a year, “AI for Salesforce developers” meant an autocomplete that guessed the next line of Apex. Useful, unremarkable, and easy to ignore. That’s not what Agentforce Vibes is anymore. Since its re-engineering, you can hand it a task in plain language — “add a discount-approval flow to the quote line editor with tests” — and it does the thing a senior developer does before touching a keyboard: it writes a plan, splits the work into pieces, spins up separate specialist workers for the Apex, the Lightning Web Component, and the Jest tests, runs them in parallel in isolated Git worktrees, and fixes its own compile errors in a loop before it shows you anything. The unit of work stopped being a line and became a feature.

That’s a genuinely different tool, and it deserves a practitioner’s read rather than a launch-post one — because the same release that made Vibes powerful also made it paid. On June 1, 2026, the free ride ended for most orgs, and teams that had wired Vibes into daily work discovered a Flex-Credit meter they hadn’t budgeted. This post is how the agentic workflow actually functions, the model tiers and pricing that ambush people, how it connects to the rest of the platform through MCP and Headless 360, and — the part that matters most — where a human still has to stand in the loop.

From assistant to agent: what “agentic development” means here

Vibes is built on Salesforce’s Coding Agent Platform and runs on the Claude and Mastra agent-orchestration engines. Strip the branding and the important shift is that Vibes plans before it acts. Give it a task and it produces a plan with an explicit structure — Goals, Non-Goals, and numbered Tasks — identifying dependencies and sequencing the work before a single file changes. That plan is the artifact you review, and it’s the first place your judgment enters: the Non-Goals section is where you catch the agent about to refactor something you didn’t ask it to touch.

Then it coordinates. A lead agent assigns work to specialized sub-agents — a Logic Builder for Apex, a Component Builder for LWC, a QA Validator for Jest — and here’s the architectural detail that makes it more than theater: each sub-agent operates in an isolated context and its own Git worktree. Worktrees are the mechanism that lets the Apex work and the LWC work proceed simultaneously without stomping each other’s files, then merge. It’s the same instinct as multi-agent orchestration on the runtime side — decompose a big job into specialists with clean boundaries — applied to the build side of the house. And it’s why the parallelism is real rather than cosmetic: separate worktrees mean separate working directories, so three agents editing three layers of your stack don’t collide.

The last piece is the self-heal loop. Vibes has LSP (Language Server Protocol) integration across Apex, LWC, and Agent Script, which means it doesn’t just generate code and hope — it reads the compiler and linter feedback the same tooling gives you in your editor, and iterates against it. Generate, check against the language server, fix the error, check again. The auto-fix loop is what closes the gap between “plausible code” and “code that actually compiles,” and it’s the difference between a suggestion engine and something you can hand a whole task to.

The shift isn’t that the AI writes more code. It’s that it plans, splits, and self-corrects before you see anything — so your review moves up a level, from “is this line right” to “is this the right plan, and did it stay inside the Non-Goals.”

Three surfaces: IDE, extension, and the CLI

Vibes shows up in three places, and which one you reach for shapes the workflow.

The VS Code extension brings the agent into the editor most Salesforce developers already use — the everyday surface for feature work alongside your existing tooling.
The browser-based Vibes IDE is a cloud-hosted VS Code environment you launch directly from your org’s Setup menu. No local setup, no SFDX project to scaffold — useful for admins and for quick work where standing up a local environment is more friction than the task is worth.
The Vibes CLI mirrors the conversational agent in the terminal. You query MCP servers, run tasks, and inspect build environments in natural language. This is the surface that fits automation and scripting — the agent where a pipeline or a power user lives, not a GUI.

The three aren’t competitors; they’re the same agent metered against the same account, which — as we’ll get to — is the thing to keep an eye on, because it’s easy to run all three and be surprised by the combined draw.

Headless 360: the platform becomes tools the agent can call

The reason Vibes can do more than generate text-in-a-box is that Salesforce exposed the platform to coding agents. Announced as Headless 360, the pitch is that everything on Salesforce is available as an API, an MCP tool, or a CLI command — Salesforce cites more than 60 MCP tools and 30 preconfigured coding skills giving an agent live access to your data, workflows, and business logic. Crucially, that access isn’t Vibes-only: the same MCP tools and skills work in other coding agents — Claude Code, Cursor, Codex, Windsurf — so your org’s metadata and logic become reachable from whatever agent your team already uses.

This is the strategically important move, and it’s easy to miss under the Vibes branding. Model Context Protocol is the standard that lets an agent discover and call tools; Headless 360 makes your Salesforce org one of those tool providers. The skills are curated, open collections — Salesforce publishes libraries like sf-skills and the Vibes-optimized afv-library on GitHub — that teach an agent the right way to do Salesforce-specific work: live query plans for SOQL (.soql files), Apex conventions (.cls, .trigger), data operations, LWC Jest scaffolding. A skill is how you stop the agent from inventing a plausible-but-wrong Salesforce pattern and make it follow yours.

The practical read: even a team that never opens Vibes should care about Headless 360, because it’s the connective tissue that lets any agent operate on your org through a governed, standard interface instead of screen-scraping or guessing. And everything we’ve written about MCP’s trust boundary applies — an agent with 60 live tools into your org is an agent whose scope you need to reason about deliberately.

The pricing that ambushes teams

Here’s the part that reorganized a lot of workflows overnight. Vibes launched free — it shipped just before Dreamforce ‘25 and a lot of teams built it into daily work at zero marginal cost. On June 1, 2026, that changed. Agentforce Vibes moved to a paid access model, and the details matter because they don’t map cleanly to “buy a license.”

The model is two-tier. Vibes starts on the Pro model — Claude Sonnet 4.5 — for chat and interactive work. When you hit your Pro limit for the period, it automatically falls back to a Core model (GPT-5 mini) for the rest of the month. So you don’t get cut off; you get downgraded, which is a subtler thing to notice. Your agent quietly gets less capable partway through a billing period, and if you don’t know the tiering exists, you’ll read it as “Vibes got worse this week” rather than “we crossed the Pro threshold.”

How you pay depends on the org:

Developer Edition keeps a limited free allowance: up to 110 requests and 1.5 million tokens on Claude Sonnet 4.5. Read the fine print — that allowance is described as a lifetime limit for the org that does not refresh monthly, and there’s no Core fallback once it’s gone. It’s for evaluation and learning, not for running a team’s daily work.
Other orgs need to pay, through either Flex Credits or the Unmetered Platform Developer and Admin AI User permission-set license. Flex Credits are the same consumption currency Agentforce meters against, so Vibes usage now draws from — or competes with — the same wallet as your runtime agents.
There’s an on-ramp: you can explore Vibes at no cost using the free Flex Credits included with Salesforce Foundations, or through a Developer Edition org.

The gotcha that bites hardest: because an agentic build fires many model calls per task — plan, then a Logic Builder pass, a Component Builder pass, a QA Validator pass, plus self-heal iterations — the credit draw per feature is not the draw of a single autocomplete. The old mental model (“it’s basically free, it just suggests lines”) is exactly wrong under the new meter. Before you standardize a team on Vibes, do the same thing we tell people to do before scaling any Agentforce workload: turn on consumption visibility, watch the credits per real task under real work, and decide deliberately between the permission-set license and the Flex-Credit meter based on your actual usage shape. The Flex Credits pricing mechanics are the same ones that govern runtime agents; the difference is that development usage is bursty and easy to under-forecast.

Where a human still has to stand

The temptation with a tool this capable is to let it run. Resist it, and design the review-in deliberately, because Vibes gives you the controls precisely so you use them. You can define approval modes for edits, enforce coding standards, and review AI-generated code before it merges. Those aren’t friction; they’re the load-bearing part of doing this safely.

The places a human has to stay in the loop, concretely:

The plan. Read the Goals and especially the Non-Goals before you let it build. The cheapest place to catch “the agent is about to touch the wrong thing” is the plan, before any worktree opens.
The tests it wrote. A QA Validator that writes Jest tests is writing the thing that proves the code is right — and an agent that writes both the code and its tests can write tests that pass a bug. Read the assertions, not just the green checkmark. This is the same discipline as testing Agentforce agents: the test is only worth what its assertions assert.
The diff, against your standards. Enforce coding standards through the tool and review the merge. Generated Apex that compiles is not the same as Apex that respects your governor-limit patterns, your bulkification conventions, or your security model. The compiler catches syntax; it doesn’t catch a SOQL query inside a loop.
The security surface. Code that touches sharing, permissions, or without sharing classes is code a human owns, full stop. An agent optimizes for “make the task work,” and “make it work” and “make it safe” are not the same objective. Anything that widens data access gets human eyes before it ships.

None of this makes Vibes less valuable. It makes it usable in a real org, where a merged mistake isn’t an embarrassing sentence — it’s a governor-limit exception in production or a sharing rule quietly loosened. The teams getting the most out of Vibes aren’t the ones who trust it most; they’re the ones who moved their review up a level and actually do it.

What to actually do this quarter

If your team is still using Vibes as a fancy autocomplete, you’re paying agentic prices for assistant value — either learn the plan-and-subagent workflow properly or scope your usage down. If you built Vibes into daily work before June and haven’t looked at the meter since, look now: confirm whether you’re on the permission-set license or drawing Flex Credits, and measure credits per real feature, not per demo. Adopt the review controls before you adopt the autonomy — approval modes and standards enforcement are the difference between speed and a merged bug. And treat Headless 360 as the bigger story than Vibes itself: the 60-plus MCP tools and the skill libraries make your org reachable from any coding agent your developers prefer, under a governed interface, which is worth wiring up whether or not Vibes is the agent you land on.

The shift is real and it’s not reversible — the coding agent that plans, splits work across specialists, and heals against the compiler is a categorically better tool than the autocomplete it replaced. But it plans your work, spends your credits, and merges into your production org, and none of those stop needing a human who reads the plan, the tests, and the diff. Move your judgment up the stack; don’t remove it.

Understanding the basics

What is Agentforce Vibes?

Agentforce Vibes is Salesforce’s agentic development tool, built on the Coding Agent Platform and powered by Claude and the Mastra orchestration engine. Rather than autocompleting lines, it plans a task into Goals, Non-Goals, and numbered Tasks, then coordinates specialized sub-agents — a Logic Builder for Apex, a Component Builder for LWC, a QA Validator for Jest — running in isolated Git worktrees, and self-heals against the language server before showing you code. It’s available as a VS Code extension, a browser-based IDE launched from Setup, and a CLI.

Is Agentforce Vibes still free?

Not for most orgs. On June 1, 2026, Vibes moved to a paid access model. Developer Edition orgs keep a limited free allowance — up to 110 requests and 1.5 million tokens on Claude Sonnet 4.5, described as a lifetime allowance that doesn’t refresh monthly, with no fallback once exhausted. Other orgs pay through Flex Credits or the Unmetered Platform Developer and Admin AI User permission-set license, and can trial it using the free Flex Credits in Salesforce Foundations. Because an agentic build fires many model calls per task, per-feature credit draw is much higher than an old-style autocomplete.

What is Headless 360 and how does it relate to Vibes?

Headless 360 exposes the Salesforce platform to coding agents — everything available as an API, an MCP tool, or a CLI command, with Salesforce citing 60-plus MCP tools and 30 preconfigured coding skills. It’s what gives Vibes live access to your org’s data, workflows, and business logic — but it isn’t Vibes-only. The same MCP tools and skill libraries (published on GitHub as sf-skills and afv-library) work in Claude Code, Cursor, Codex, and Windsurf, so any coding agent can operate on your org through a governed, standard interface.

Standardizing a team on Vibes and trying to get the workflow and the credit model right before it becomes a surprise line item — or wiring Headless 360 into the coding agents your developers already use? Talk to us. Getting agentic development into a real org safely is the kind of work we do.

Agentforce Vibes pricing and licensing: what changes when the coding agent builds in parallel