Agentforce for DocGen puts a Generate with Agentforce button in the Visual Designer. Tell it what you want in plain English and it writes the HTML template — using your actual query fields, the DocGen tag syntax, and the PDF engine's real layout limits. Then it checks its own output against that engine and tells you what it had to fix.
Requires DocGen 3.46+ and Einstein / Prompt Builder in your org — Salesforce enforces both at install. The app itself is, and stays, free forever.
DocGen has always had Copy AI Prompt: it assembles your fields, the full merge-tag cheat sheet and the engine's rendering constraints, and hands you the text to paste into ChatGPT or whatever you use. That's free, and it isn't going anywhere. This extension sends that same prompt to Salesforce AI inside your own org instead, catches what the model gets wrong, and drops the result straight onto the canvas. You're paying to close the loop, not for the intelligence.
A Statement of Work, start to finished PDF. The breakdown underneath is the honest sequence — including the step you do first, before the agent is involved at all.
Prefer to watch it on YouTube? Open the demo in a new tab → Nothing loads from YouTube until you press play.
In DocGen's visual query builder — base object, fields, parent lookups, child relationships. Point and click, no SOQL. This has to exist first, because it's what the agent writes against.
Open the Designer, press Generate with Agentforce, and say what you want in sentences. Your fields, the tag syntax and the engine's layout rules are attached automatically.
Constrained to the fields your query actually returns — the prompt tells the model to use only those, because anything else would render as empty text in the finished document.
Before anything is saved, the output is checked against the PDF engine's measured limits, repaired where it can be, and you're told what changed. Then it lands on the canvas.
Editing is the default, not starting over. Once a template is on the canvas, your next instruction is sent with the current body — unsaved edits included — so it revises rather than regenerates. Every edit is diffed against what went in, and if a merge tag went missing you're told which one, by name. Generation runs 10–25 seconds and consumes Einstein usage against your org.
Ask any general model for print HTML and it returns flexbox, rounded corners and translucent tints — we asked for CSS 2.1 explicitly and it still emitted display:flex three times in one generation. DocGen renders with Flying Saucer, which silently ignores all of that. So every generation is checked against what the engine measurably supports before it is saved.
Translucent rgba() tints composited over white into flat hex — they don't fall back to a colour, they resolve to nothing and the panel renders invisible. Gradients collapsed to their first stop, var() substituted, numeric font weights mapped, Visualforce-style {!Field} rewritten, markdown fences stripped.
border-radius in every form, box-shadow, text-shadow, opacity, transform, calc(), CSS columns, @media, <script>, <svg>, external stylesheets. The engine ignores them, so deleting them changes nothing on the page and leaves the source honest.
Things it won't silently rewrite because the fix is a judgement call: display:flex or grid that needs a real table rebuild, position:absolute, ZapfDingbats, a {PageNumber} stranded in the body, unbalanced braces. Flagged for you, left alone.
The single most common thing a model gets wrong: it wraps {#Rel} around the whole <table>, which repeats headers and all, once per child record. The validator moves the loop tags into the first and last cells of the data row where they belong.
A bad generation is obviously bad; a bad edit is invisible — a dropped {Amount:currency} renders as nothing and the canvas looks fine. Every edit is compared against what went in, and lost tags, truncation, a dropped @page and vanished tables are reported specifically.
The model is reached through ConnectApi, not an HTTP callout — Limits.getCallouts() stays at 0. It's Salesforce AI in your own org, under your org's own Einstein configuration. DocGen stays 100% native, exactly as it was.
Better to read this before you install than after.
The Visual Designer is for HTML templates, and the Agentforce button lives in the Designer — so that's the whole of what the agent authors. Word, Excel and PowerPoint templates you still build by hand in Word, Excel and PowerPoint, exactly as before.
This is a limit on authoring, not on DocGen. The engine still merges and outputs Word, Excel, PowerPoint and PDF just as it always has — nothing about your existing templates changes. If you want a .docx or .xlsx template built for you, that's a flat $199 build.
The agent writes against a query config that already exists — the prompt literally instructs the model to use only the fields your query returns, because anything else renders as empty text.
So you build that first, in the visual query builder: base object, fields, child relationships. It's point-and-click rather than SOQL, but it's a real step and the agent does not do it for you.
It writes a template. It doesn't build the record-triggered Flow that fires it, the scheduled bulk run, the e-signature routing, or the integration on the other end.
That's implementation work and it goes where it always did — the User Guide if you're doing it yourself, or our implementation partners if you'd rather not.
It won't walk you through its reasoning or annotate the syntax it chose. You get a template, not a lesson. The one thing it does explain is what the validator changed and why — that report you always get.
If you want to understand what's underneath, and it's worth knowing since you'll hand-edit eventually, the free User Guide is where that lives.
Each generation takes 10–25 seconds and consumes Einstein usage against your org, on your org's own entitlement. We don't meter it; Salesforce does.
Pick the model deliberately. Prompt Builder defaults to GPT 5 Mini, which we measured applying multi-part edits only partially and sometimes replying "I don't know." instead of returning a document. A stronger model applied 4/4 changes every run.
The base package is the app, and it's free. The extension is the provider and the prompt template, and it asks for a key.
Version 3.46 or later — get it from the AppExchange listing, the same place everyone installs DocGen. Already running it? Take the latest anyway; the extension depends on 3.46+. Upgrading is a normal managed-package install: templates, query configs, generated documents and permission set assignments all carry through untouched.
Prefer the CLI? sf package install --package 04tVx000000s7yzIAA --wait 10 --target-org your-org
Carries the Einstein provider class and a ready-made prompt template — nothing to write or configure. Installing prompts for a password, which arrives in your private support channel once your membership is active, usually within about 15 minutes of checkout.
Trying it in a sandbox first is the sensible move, and it's the same password either way. Don't have one yet? Start Premium Support and it'll be waiting for you — already a member and can't find it? Just ask in your channel.
Not packaging strategy — a hard platform constraint, and we measured both halves of it. An Apex class referencing ConnectApi.EinsteinLLM builds fine but is refused at install in any org without the Einstein entitlement. A packaged GenAiPromptTemplate is worse: it makes the entire package declare a feature requirement, so every customer without Einstein would be blocked from installing DocGen at all. Keeping both outside the base package is precisely what lets DocGen stay installable everywhere, for everyone, for free.
Install the base first. Salesforce enforces both the DocGen 3.46+ dependency and the Einstein requirement at install time, so a wrong order or a missing entitlement fails fast rather than half-installing.
There's no separate Agentforce price to work out. Any active Premium Support membership — including the $49.99 solopreneur tier — comes with the extension password. Install it once and it's yours to keep; membership is what keeps it current.
Build as many as you want. We don't add a ceiling — your Salesforce org and its Einstein usage are the only limits.
Every revision, reword and restyle. Iterating is the whole point, so it isn't metered.
Every new version as it ships, at no extra cost, while you're a member — and the version you're on stays yours if you stop.
The extension has no kill switch. Once installed it stays unlocked, and you hold an unlimited licence to the version you were on at your last payment — generate and revise as much as you like, forever. A membership buys upgrades: new versions ship with new install codes, and those go out through the Premium Support channels only. Lapse and you simply stay where you are. Rejoin and you're current again.
Membership also gets you a private channel in Slack or Microsoft Teams with the people who build DocGen, free tweaks to your existing templates, and flat $199 template builds when you'd rather hand a document to us entirely. Cancel any time and you keep what you paid for — see what happens if you stop.
Portwood .docx or .xlsx template made for you? That's a flat $199 build.ConnectApi rather than an HTTP callout — Limits.getCallouts() stays at 0 — so it's Salesforce AI running in your own org under your own Einstein configuration, and DocGen keeps its "no external services" guarantee intact. We never see the prompt or the response. Document generation itself is completely unchanged: merging and PDF rendering happen in-org, as always.display:flex three times in a single generation. So every result is checked against the PDF engine's measured limits, repaired where a safe equivalent exists, stripped where the engine would ignore it anyway, and flagged where the fix needs your judgement. You're told what changed and why, every time. Then you preview it as a PDF against a real record before it goes anywhere near a customer.@page and vanished tables. It never blocks or silently rewrites, since losing a tag can be exactly what you asked for. Previous bodies stay in the template's file history, and the raw model output is staged separately so it can always be compared against what was saved.DocGenAiProvider is a global interface in the free base package — implement it, point DocGen Settings > AI Provider Class at your class, and DocGen will use that instead. The extension is simply the turnkey version: the Einstein implementation plus a ready-made, activated prompt template, so there's nothing to write or configure. Which model Prompt Builder uses is also yours to choose, and worth choosing: it defaults to GPT 5 Mini, which we measured applying multi-part edits only partially. See User Guide section 5.7.11.