Describe the work in plain language. OrgBolt drafts it, flags the risks, and deploys when you're ready.
When an Opportunity is set to Closed Won, recalculate the parent Account's total lifetime value from all its Closed-Won Opportunities and set a customer tier from that total. Build it as a record-triggered Flow — no Apex. Use a Loop over the Closed-Won Opportunities and a Formula for the running total.
Before I build this, let me challenge one part of the requirement — and flag a real Salesforce gotcha in it.
The Loop + Formula-for-running-total approach won't actually work in Flow. Flow formulas are stateless — they recompute from their inputs every time they're referenced; they can't accumulate a running total across loop iterations (a formula can't reference itself). The canonical Flow pattern for a running sum is a Number variable + an Assignment element with the "Add" operator inside the loop. So I'll keep your Loop, but use an Assignment (not a Formula) to accumulate. That's the standard, maintainable way to do it in Flow.
Here's my plan for the record-triggered Flow on Opportunity (fires when Stage becomes Closed Won):
StageName = Closed Won (this includes the current one, since it's committed before an after-save flow runs).Amount into a running Number variable.Two things I need from you before generating:
1. Target fields on Account. I don't see a lifetime-value or tier field on Account today. I'll create two new custom fields:
Lifetime_Value__c (Currency)Customer_Tier__c (Picklist)Just confirm the tier picklist values and their thresholds. A common setup:
Want these, or different labels/breakpoints?
2. Flow type. This is a cross-record update (Opportunity → parent Account), so it must be an after-save record-triggered flow. Good to proceed on that basis?
Everything targets Dev Box (sandbox), and I'll ship the flow as Draft so you can eyeball the version in Setup before activating.
Use those tiers, go ahead
Everything's staged: the two new Account fields and the after-save record-triggered Flow (as Draft). One design note — I used an Assignment with the Add operator inside the loop for the running total rather than a Formula, because Flow formulas are stateless and can't accumulate across iterations. Same intent, correct Flow mechanics.
One thing before deploy — field-level security. New custom fields are hidden until a permission set grants access. The most fitting existing set is Account_General; I've also surfaced a couple of others plus a "browse all" option so you can pick the right destination. Which should get Read/Edit on Lifetime_Value__c and Customer_Tier__c?
Add the fields to your pages: The new Lifetime Value and Customer Tier fields on Account won't appear on record pages until you place them. For classic layouts: Setup → Object Manager → Account → Page Layouts → open the layout(s) your team uses → drag Lifetime Value and Customer Tier into a section → Save. For Lightning pages using Dynamic Forms: Setup → Object Manager → Account → Lightning Record Pages → edit in App Builder → add the two fields from the Fields tab. (FLS is handled by the permission set you pick above.)
Manual step after deploy: the Flow ships as Draft — verify the version in Setup → Flows, then activate it (or redeploy with status Active) to turn it on.
Grant access via Account_General


You're giving a tool access to your Salesforce org, so here's exactly what it can and can't touch.
OrgBolt reads your org's metadata — objects, fields, flows, permissions. Reading record data is off by default: you grant it per org, you revoke it whenever you want, and every grant and revoke lands in an audit trail.
Your prompts and metadata are never used to train AI models, and Anthropic deletes API inputs within 30 days. Want AI under your own contract? Bring your own key — included.
Everything is encrypted in transit and at rest. Salesforce tokens live in an isolated vault with authenticated encryption — the database role your browser session uses cannot read them, or even the pointer to them. Every workspace is tenant-isolated at the database layer.
The full picture — sub-processors, retention, deletion — lives on the security page.
Not an agent inside your org: OrgBolt builds each change as a package, validates it against your org with tests, deploys it, and keeps the transcript. No Agentforce, Einstein or Data Cloud licence needed. Connect, describe, deploy.


Step 1
Sign in with Salesforce OAuth, sandbox or production. OrgBolt indexes the metadata and keeps the index fresh.


Step 2
Plain language in, a drafted change out, with the risks flagged and the decisions asked one at a time.


Step 3
A check-only run against the real org, tests included. Fix what fails, then deploy the validated package.
The org work that usually needs a second tool — documentation, impact analysis, reference maps — is one conversation away.


Say “document the Account object” and get a structured document — field tables, automation inventory, live relationship diagrams — grounded in your org’s real metadata, honest about what it read and what it skipped. Saved to the task, exportable as markdown.


Run any change as a check-only validation against the real org — tests included. Fix what fails, then Quick Deploy the already-validated package without running everything twice.


With your explicit go-ahead, the AI can also query record data — counts, sums, and row sets rendered as sortable tables. Off by default, granted per org, revocable anytime, and every read lands in the audit log.


Type /planning before you build and OrgBolt pressure-tests the plan — one question at a time, grounded in the flows, rules, and permissions your change actually touches. It ends with a written summary of decisions and risks that the build then follows.
Pick any component on the Org page and see what it uses and what uses it — flows, Apex, Lightning components, layouts, test coverage — with every edge a click into a fresh search. Dependencies parsed from Apex source and Lightning components included.
Before a rename, delete, or type change, OrgBolt runs Salesforce’s own “where is this used?” check — flows, validation rules, Apex, layouts — and tells you what would break before anything does.
New fields are invisible until field-level security says otherwise. OrgBolt ships the access grant with the change — merged into the permission sets you already use or a new one — and assigns you on deploy, so your fields show up immediately.
OrgBolt keeps a synced index of your org's metadata — swept for changes on a schedule, refreshable on demand, with its age always visible in the task bar. The AI reasons over what your org looks like now, not a stale snapshot.
How each one works, in detail, lives in the documentation.
Permission Inspector
Ask in plain language. OrgBolt walks your org's visibility model — license, object and field permissions, record types, sharing, restriction rules, page visibility — and names the layer that decides, with the evidence to check in Setup.
Why can't Jack Wilson see Annual Revenue on Account?
Jack Wilson has object-level Read access to Account (via the "OB QA Account Access" permission set), but no field-level security grants him Read on Annual Revenue — no profile, permission set, or permission set group he's assigned gives read access to that field (and none grants "View All Fields" on Account either). That's why it's hidden for him.
The cleanest fix is a permission set granting Read (and Edit, if he needs it) on Account.AnnualRevenue. There's an existing permission set, OB QA Revenue Visibility, that already grants exactly this field access and nothing more — assigning it to Jack would be the smallest change. Alternatively, you could create a new permission set scoped just to this.
Every verdict cites the profile, permission set, sharing rule, or page that caused it — check any claim in Setup. Where Salesforce publishes no answer, the trace says “not traced” instead of inventing one, and OrgBolt asks Salesforce's own access check the same question and flags any disagreement.
A denial ends in the existing permission set that adds the fewest privileges this user doesn't already hold — scored by arithmetic, not ranked by the AI — or a new set scoped to just the missing access. Apply it, the trace runs again, and you close the ticket with before-and-after proof.
An expired assignment still blocks re-assigning the set, but Salesforce hides it from ordinary queries. OrgBolt reads the API that still returns it, tells you access ended rather than never existed, and renews the exact assignment for a window you choose.
Record-level questions read record data, which stays off until you allow it per org — the trace still completes without it and says what it skipped. How the Inspector works.
One plan with everything OrgBolt does. Scale up with add-ons only when you need them — no tiers to compare, no upgrade math.
14 days free, no credit card
$99/mo
Everything OrgBolt does — every metadata type, every AI model.
Buy the lever you need, one at a time. No plan change.
Invite more teammates. Add one in-app the moment you hit the limit.
Connect more Salesforce orgs, one at a time.
Standing instructions the AI follows on every task in the workspace — your naming rules, test patterns, approval steps.
50,000 more credits that never expire while you're subscribed.
Your 75,000 monthly credits cover roughly 13 tasks a month taken from first message to deploy or cancel, at about 10 messages each. A typical message runs about 550 credits, or 1050 in Smarter mode, the higher-reasoning level you can switch on per task; bigger asks cost more.
Cancel any time. Billed monthly via Lemon Squeezy, our merchant of record.
The safety questions — production, failed deploys, undo — have their own answers in the docs FAQ.
Agentforce puts AI agents in front of your users and customers. Setup with Agentforce (in beta) is an assistant inside Setup that changes the org you are in once you approve. Agentforce Vibes is a coding assistant for developers in an IDE. Claudeforce, the Salesforce and Anthropic partnership, puts Salesforce records and sales skills inside Claude for reps: it reads and updates CRM data, not your org's configuration. OrgBolt is the admin's change tool: it builds a change as a package, validates it against the org with tests, deploys it, and keeps the transcript and the artifacts, sandbox to production. It needs no Agentforce, Einstein or Data Cloud licence, runs on any edition with API access, costs $99 a month flat, and can use your own Anthropic key.
Both. Start with a sandbox: the trial connects one org and Work never writes to it. On a production org, Deploy defaults to Validate first (a check-only run that changes nothing) and you deploy the validated package with a second click.
Enterprise, Unlimited, Performance and Developer editions, sandbox or production. Professional Edition needs Salesforce's Web Services API add-on, and even then Salesforce lists the Metadata API that deploys use as unsupported there, so treat Professional as read-only until you've tested it on your org. Essentials and Starter have no API access.
No. OrgBolt ships its own Connected App; you sign in with Salesforce and approve the scopes. If the login fails before any consent screen, your user is missing Salesforce's “Approve Uninstalled Connected Apps” permission (required since September 2025); an admin grants it or installs the app once from Setup.
Messages pause until your monthly credits reset or you buy a top-up; nothing you built goes anywhere. Top-up credits are drawn only after the monthly allowance and never expire while you're subscribed.
No. 14 days, 10,000 credits, one user, one connected org, and full access to Work and Deploy against a sandbox. Prove it works on a real org before you pay for anything.
Yes. You can belong to several workspaces, one per client, and each workspace connects its own orgs with its own audit trail. Add more orgs to a workspace one at a time as an add-on.
From the founder
“I've been a Salesforce admin and developer for fifteen years, and most of that time the hard part wasn't the change, it was everything around it: the second tool, the pipeline, the permission set nobody remembered. OrgBolt is the way I wanted to ship a change: say it, check it, deploy it, and have a record of what happened.”
Connect a sandbox, describe one real change, and watch it validate and deploy before you pay for anything.