We Built an AI That Knows Your Salesforce Store

Julia Dunkovich
November 20, 2026
•
10 min
Most teams don't lack answers; they lack a fast way to reach them. The McKinsey Global Institute estimated over a decade ago that knowledge workers spend nearly 20% of their week looking for internal information or tracking down colleagues who can help, and that a searchable record of company knowledge could cut that time by up to 35%.

The pattern persists: a recent Gartner survey of more than 5,700 customers found only 14% of service issues were fully resolved through self-service, with failure to find relevant content the most common reason. Gartner noted that companies usually have plenty of content already; navigating to it is the hard part. A Salesforce B2B Commerce store after go-live is a textbook case: hundreds of pages of Admin Guides, hours of recordings, and support requests for answers that are already written down.

That gap is exactly what AdminPilot was built to close. AdminPilot is an AI assistant that answers Salesforce B2B Commerce admin questions from a store's own documentation. An admin types /ai or /ai_light in Cursor or Claude Code and asks in plain English. AdminPilot searches the store's Admin Guide, demo recording transcripts and Salesforce Help, then returns short steps with a link to the exact source page or recording time span.

‍

I'm Julia Dunkovich, and I built AdminPilot over seven weeks at ForteNext. On 57 real client questions, its pass rate rose from 53% in the first prototype to 91% in the third.

This article walks you through it in order:

  1. The problem it solves, and why generic AI doesn't solve it
  2. What using it looks like, with a real example
  3. How it finds the right answer
  4. Why you can trust what it says
  5. What you need to get started, and what it can't do
  6. What I learned building it, for Salesforce teams thinking of doing the same

If you just want the facts, the summary table below has them all.

‍

AdminPilot at a glance

AttributeDetail
What it isAn AI skill that answers "how do I…" questions about a specific Salesforce B2B Commerce store
Built byJulia Dunkovich, Business Analyst, ForteNext
Built forSalesforce admins, e-commerce operations managers and business users who run the store after go-live
Runs inCursor or Claude Code, through the /ai and /ai_light commands
Knowledge sources, in priority orderStore Admin Guide → demo transcripts → Salesforce B2B Commerce Help → wider Salesforce documentation
RetrievalLocal semantic search with the open-source paraphrase-multilingual-MiniLM-L12-v2 embedding model
Language modelModel-agnostic: whichever model is selected in Cursor or Claude Code
Accuracy91% pass, 7% partial, 2% fail on 57 real client questions (third prototype, manual rating)
Typical answer timeAbout 1.5 minutes for /ai; about 1.2 minutes for /ai_light
StatusTested internally on the knowledge bases of two client stores, about 360 logged runs over two months; not yet rolled out to clients
Cost to clientsNo additional cost for stores ForteNext implemented from scratch
The problem: store admins can't find answers that already exist

Every ForteNext store launches with a full set of documentation. The difficulty isn't missing information. It's reaching the right piece of it quickly, at the moment someone needs it.

Store documentation runs to hundreds of pages and several versions

Alongside the store itself, the client receives Admin Guides and recordings of the demo and knowledge-transfer sessions. Nearly everything the team will need is in there.

But the volume adds up. One client has a single 266-page Admin Guide. Another has three releases of its guide published over one year: 512, 170 and 152 pages, or 834 pages in total.

Those versions cause a second problem. A new release often doesn't mark which older sections are out of date, and a module can be renamed between releases. It's easy to follow steps that no longer apply.

So a simple question turns into a search, or a support ticket

Take "How do I create a Buyer Group?" It sounds simple. In practice, the admin opens the guide, searches the transcripts, tries to remember which call covered it, and checks Salesforce Help. The answer exists. Finding it takes time.

If that search fails, or there's no time for it, the admin contacts the development team or opens a case with their Salesforce partner. Either way, the client waits for an answer that is already written down, and Support spends its time searching instead of fixing real issues.

Most questions are everyday "how do I…" tasks

These are the five questions client admins ask most often after go-live:

  1. How do I create and set up a Buyer Group?
  2. How do I set a minimum or maximum order quantity for a product?
  3. How do I hide a product from search results?
  4. How do I add a new link to the footer?
  5. Is this possible out of the box, or does it need custom development? (For example, guest checkout rules or tax setup.)

The first four are routine configuration tasks. The fifth is where generic tools most often go wrong, as the next example shows.

Generic AI and Salesforce Help don't know how your store was built

ChatGPT and Salesforce Help know the Salesforce platform well. What they can't know is how one particular store was configured: its custom fields, custom settings and project-specific processes.

One client asked: "Can we calculate taxes for different states on different Avalara accounts?" Salesforce Help says a store connects one tax service, which a reader could take as "yes, just configure it." But this store uses custom Avalara settings with a single Company Code from one Avalara profile. The honest answer is "not out of the box; this needs custom development." A generic answer would have sent the admin hunting for a setting that doesn't exist.

That is the gap AdminPilot fills: it connects general Salesforce knowledge to the documented reality of one specific store.

‍

What using AdminPilot looks like

Before looking at how it works, here's what an admin actually experiences: a question in plain English, a short answer, and a link to check it.

A real question, answered in 40 seconds

This example comes from testing on a real client question, with the client anonymised. AdminPilot hasn't yet been rolled out to client admins.

  • The admin asks: "How do I make a product invisible in search results?"
  • AdminPilot searches: the store's Admin Guide, the demo transcripts and Salesforce Help.
  • It answers, in about 40 seconds: steps to mark the product as Not Searchable for that store. It adds two useful details: the setting works per store, and an active product still appears in the store, just not in search results.
  • It names its source: the Salesforce Help article "Mark Products as Searchable or Not Searchable".

Every answer follows that pattern: short steps using the names on the Salesforce screens, then a Source line the admin can open to check.

Two commands: full steps, or just the source

Admins choose how much help they want. Both commands use the same search and the same rules; they differ only in what they return.

CommandWhat you getBest forTypical time
/aiStep-by-step answer plus the Source lineAdmins who want guidance through a taskAbout 1.5 minutes (20 seconds to a few minutes)
/ai_lightSource links only: guide page, transcript time span or Help articleExperienced admins who know the topic and just want the right pageAbout 1.2 minutes

‍

How AdminPilot finds the right answer

You don't need to know any of this to use AdminPilot. But it explains why the answers fit your store, and why you can check them. Every question goes through the same six steps:

  1. It checks the question. The question must be in English and about the B2B Commerce store. Anything else gets a polite "out of scope".
  2. It works out what you're really asking. The AI uses its general Salesforce knowledge to identify the objects, settings or Setup menus involved. This only sharpens the search; it's never shown as an answer.
  3. It searches by meaning, not keywords. Every passage in your guides and transcripts has been turned into a numeric "fingerprint" of its meaning, called an embedding. AdminPilot finds the passages whose meaning is closest to your question. That's why "limit how much a customer can order" finds the "Quantity Rule" section, even though no words match.
  4. It picks the source it trusts most. Your store's Admin Guide comes first, then the demo transcripts. Salesforce Help is checked only if those don't answer the question.
  5. It answers like a colleague would. You get short steps with the exact button and field names you see on screen, plus a Source line. If nothing answers the question, it says so instead of guessing.
  6. It keeps a record. Each run is logged with the question, answer, model and time, so any answer that goes wrong can be traced and the rules fixed.

Four rules inside those steps matter most to admins.

‍

How AdminPilot answers a question

Scroll sideways to see the whole diagram.

Select any step to see what happens there.

Your store's own guide always outranks generic help

The order of sources is fixed: store Admin Guide → demo transcripts → Salesforce B2B Commerce Help → wider Salesforce documentation. A lower source is used only when the ones above it don't cover the question. If your Admin Guide and Salesforce Help disagree, the guide wins, because it describes how your store was actually built.

It always answers from the newest version of your guide

AdminPilot reads each guide's release date and its Revision History. "Newest" means the latest release date, not the highest version number, because a later file can carry a smaller number. If the newest guide changes a section, only the new steps are used. If it added a section, old and new are combined. Conflicting steps from two releases are never mixed.

Answers use the button and field names you see on screen

Steps follow the click path, in order: tab, record, section, field. AdminPilot uses the exact labels from your documentation and never swaps them for technical API names. If the only source is developer documentation, it rewrites the answer as clicks in Setup or the Commerce app, with no code.

When the source is a recording, the Source line names the transcript and the time span, for example "Transcript 2, 4:00–4:44". You then jump to that point in the video yourself.

Your documents stay on your machine

The search runs locally, using a small open-source model (paraphrase-multilingual-MiniLM-L12-v2) that works offline on an ordinary laptop. Here's what stays and what is sent:

DataWhere it goes
Full Admin Guides, transcripts, search index, embeddingsStay on the local machine
The question, the matching passages, the skill instructionsSent to the AI model through Cursor or Claude Code
A search querySent to Salesforce documentation search, only when Salesforce Help is needed

So your full guides are never uploaded to a separate service, and the search itself adds no cost per question.

‍

Why you can trust the answers

An AI assistant is only useful if admins can rely on it. So AdminPilot is built to say "nothing found" rather than improvise. Five rules enforce that:

  • It only uses facts it found. Answers may draw on the passages the search returned or on official Salesforce Help pages, never on the AI model's general memory.
  • Every answer shows its source, built from the search results and never invented.
  • It admits when it can't answer. If no source supports an answer, it replies: "Nothing was found for this question in the Admin Guide, project demo files, or Salesforce Docs."
  • General knowledge is labelled. It's allowed only for standard platform facts, and must link to official Salesforce documentation.
  • Plans aren't presented as features. Ideas or mockups discussed in a demo are labelled as plans, not as how the store works today.

Two more safeguards deal with the mistakes AI assistants make most often.

It tells you first when something needs custom work

Remember the Avalara tax question? AdminPilot handles questions like that with a specific rule. It first checks whether your store's documents describe the feature, then whether it's a standard B2B Commerce feature. Only if both say no does the answer open with: "This is not a standard Salesforce B2B Commerce feature and is not available out of the box. A custom solution would be required to support this functionality."

That sentence comes first because it changes what you do next. You need a change request, not a setting. Without it, an admin can lose an hour hunting for a checkbox that doesn't exist. And if AdminPilot isn't sure, it doesn't make this claim at all.

It rejects answers that are only "almost right"

This was the hardest problem to solve. The AI would find a passage that mentioned the same screen or field as the question, but described a different action, and present it as the answer. The fix is an explicit action-match rule: a passage counts only if its steps do what the user actually asked.

It has been tested on 57 real client questions

Colleagues collected 57 questions that real clients had asked, and I rated every answer by hand as Pass, Partial or Fail. The pass rate rose from 53% in the first prototype to 77% in the second and 91% in the third, with failures down to 2%. You'll find the full history in the build story further down.

‍

What you need to get started

If your store was built by ForteNext, AdminPilot works with the documentation you already have. Here's who it's for, what it needs, and how it fits alongside your Support team.

It's built for the people who run the store, not developers

AdminPilot is for Salesforce admins, e-commerce operations managers and business users who configure the store. Answers use screen names, buttons and field labels, never code. Less experienced admins will get the most from full answers with /ai. Experienced admins who just need the right page will prefer /ai_light.

The setup is light
  • A Cursor or Claude licence that supports skills
  • Python, installed once
  • An ordinary laptop; no special hardware is needed
  • Your store's Admin Guide (Word, plus a PDF for page links) and the demo transcripts, placed in the project folder

On the very first question, AdminPilot builds its search index, which takes a few minutes. After that, anyone comfortable with an AI chat tool can use it. It adds your store's knowledge, not a new interface to learn.

It stays up to date as your store changes

When your store changes, drop the updated Admin Guide or a new transcript into the knowledge base folder. On the next question, AdminPilot notices the change and rebuilds its index automatically. Salesforce Help is searched live, so answers about the standard platform always follow Salesforce's current documentation.

Your Support team handles what AdminPilot can't

AdminPilot runs on your side and answers routine, documented questions on the spot. That frees ForteNext Managed Services to focus on real issues. A question goes to a person when AdminPilot finds nothing, when it flags that custom work is needed, or when the problem is a live incident or an integration failure.

What AdminPilot can't do

It's just as important to know where AdminPilot stops. It explains documented configuration; it doesn't replace an admin's judgement or your Support team. Today it:

  • Works in English only. Questions in other languages are out of scope.
  • Is only as good as your documentation. If something isn't documented, the answer is "nothing found".
  • Doesn't see your live Salesforce org. It explains the configuration as documented, not the org's current state.
  • Never changes anything. It explains steps; it doesn't carry them out in Salesforce.
  • Points to recordings but doesn't play them. It names the transcript and time span; you open the video yourself.

Don't use it for live incidents, integration or data-sync failures (for example, orders not syncing to an ERP), data fixes, or decisions that need a human review, such as security, tax or legal questions.

‍

How I built AdminPilot, and what I'd tell other Salesforce teams

This section is for Salesforce teams who are curious about the build, or thinking about something similar. It covers how the prototypes evolved, what failed, and the lessons I'd pass on.

Seven weeks, three prototypes, from 53% to 91%

I designed and tested AdminPilot myself, as an AI skill on top of Cursor. With no backend or user interface to build, each prototype took weeks rather than months. Each one was tested on the same 57 real client questions.

PrototypeWeeksWhat changedPassPartialFail
POC 11Search by meaning over one Admin Guide and the demo transcripts; every run logged; AI models compared53%12%35% (49 of 57 rated)
POC 22–3Plain-language answers; links to the exact guide page; Salesforce Help as a fallback; guide updates picked up automatically77%16%7%
POC 34–7Several guide versions, answering from the newest; /ai_light; the "not out of the box" warning91%7%2%
The first version failed on store-specific questions

The first skill, /doc, searched only the project documents. On real client questions it failed often, and all 17 failures in that round were store-specific questions the documents didn't answer directly.

So I changed the order. Now the AI first works out what the question is about, using its general Salesforce knowledge, and only then searches the documents. Later I added the Salesforce Help fallback, the "not out of the box" rule and support for several guide versions, and merged /doc into /ai.

A couple of plans changed along the way. /ai_light was meant to be a Cursor "custom mode", but Cursor 2.1 removed custom modes, so it became a command. I also considered a web app, then parked it: a Cursor skill was much faster to build and test.

How the documents are prepared for searching

Admin Guides are split along their own headings, section by subsection, into passages of up to about 1,200 characters. Each passage keeps its heading path, its real PDF page range, and the guide's release date and version. Transcripts are split by timestamped speech. Four lessons shaped this design:

  • Metadata matters as much as text. The release date tells AdminPilot which version to trust. The exact page is what makes an answer checkable.
  • Take page numbers from the PDF. Word's table of contents gets them wrong.
  • Use a score threshold, not a fixed "top 5". Each passage gets a similarity score from 0 to 1. AdminPilot keeps every passage scoring 0.4 or higher, and the AI then checks which ones actually answer the question.
  • Keep instructions whole. If AdminPilot finds part of a section, it pulls in the whole section so the steps stay in order.
The AI model matters as much as the rules

AdminPilot works with whichever AI model is selected in Cursor or Claude Code. The rules live in plain-language skill files; the indexing, search, page links and logging are Python code.

The run log showed that the model choice still matters. On the same skill version, two models answered the same question from different sources. One used general Salesforce developer documentation; the other used the store's own Admin Guide, and answered five times faster. Across my first comparison, Claude Opus 5 used the Admin Guide in 92% of answers, against 25% for Grok 4.6 in Cursor. It was also faster, at about 1.1 versus 1.9 minutes on average, though Grok used slightly fewer tokens.

A typical run reads 200,000–300,000 tokens, almost all of it source material; the answer itself is 2,000–10,000 tokens. These figures come from testing in Cursor.

‍

Six lessons for building a trustworthy AI assistant

  1. Connect the project's own knowledge, and search it first. General AI knows Salesforce, not how a particular store was built. Salesforce Help belongs in the second layer.
  2. Translate the question before searching. Clients ask in their own words, not the guide's. Map the question to Salesforce objects and settings first.
  3. Give every answer a source. A guide page, a recording time span or a Help article. Without one, nobody can check the answer.
  4. Make "needs custom work" a high bar. Claim it only when both the project documents and Salesforce Help confirm it. If unsure, say nothing was found.
  5. Test each question several times. The same question can get different answers, so one good answer proves little. Use real client questions, not only ones written from the documentation.
  6. Rebuild the index automatically. If someone has to remember to rebuild it, the AI will eventually answer from an old version.

‍

What's next for AdminPilot

ForteNext's main goal for AdminPilot is to keep answer accuracy above 90%. The wider roadmap is still being set, but the options on the table include:

  • Automated evaluation, so every new model or document is checked straight away
  • A web interface for users who'd rather not work in Cursor
  • A read-only connection to the store's Salesforce org, for example through the Salesforce DX MCP server, so answers can reflect the live configuration

The approach isn't limited to B2B Commerce, either. It works for any Salesforce implementation with its own documentation and recordings.

Looking further ahead, I see AI admin support moving from answering questions to doing the work. First, AI explains how things are set up. Next, it sees the live Salesforce org. Then it prepares changes that an admin reviews and approves. AdminPilot itself answers questions; for AI that takes actions in Salesforce, ForteNext offers separate services.

‍

Frequently asked questions
Why not just use ChatGPT, Agentforce or Salesforce Help search?

Those tools know Salesforce in general, but not how a specific store was built. AdminPilot answers from the store's own Admin Guide and demo recordings first, linking to the exact page or time span. When something isn't available out of the box, it says so plainly, and the store's documents stay on the client's machine.

Is our documentation uploaded anywhere?

No full documents leave the machine. Guides, transcripts, the search index and embeddings stay local. The AI model receives only the question, the matching passages and the skill instructions. Salesforce documentation search receives a search query, only when Salesforce Help is needed.

Does ForteNext see our questions?

The run log was built for ForteNext to use during development and testing. It records only /ai and /ai_light commands, never ordinary chat. Once AdminPilot is set up for a client, it runs on the client's machine and the logs stay there; the client owns them and decides how long to keep them.

How accurate is AdminPilot?

On 57 real client questions, rated manually, the third prototype passed 91%, was partial on 7% and failed 2%. The first prototype passed 53%. Accuracy depends on the quality of the documentation and on the AI model selected.

What does it cost, and what do we need to prepare?

Clients whose store ForteNext implemented from scratch pay nothing extra for AdminPilot. AI model usage runs on the client's own Cursor or Claude licence. The knowledge base is the Admin Guide and demo transcripts produced during the project, so no new documentation is needed.

How much time does it save?

ForteNext estimates 20–70% of time saved on store troubleshooting. This compares manual searching with AdminPilot; it isn't a formal study. The low end is an admin who already knows where to look. The high end is someone who would otherwise dig through the guide, the recordings and Salesforce Help.

See AdminPilot on your store

If your team runs a Salesforce B2B Commerce store and spends time hunting through guides and recordings, see how AdminPilot works.

About the author

Julia Dunkovich
Salesforce Business Analyst