Do this with AI
Install the dx-mcp-server skill from Contentstack agent skills. Then ask your agent:
I want an agent to find blog posts that aren't translated into German yet and then draft the missing translations. Which MCP Profile Hub system profiles should I connect for each step, and which tools in them can change content?
New to this? Set up your AI workbench first.
Pick the right Profile Hub profile for the job
The profile you connect decides what your agent can do on your stack, so it deserves more thought than the first item in the list. My rule is simple: pick the narrowest profile that can finish the job, and switch profiles when the job changes. This post maps everyday developer and content jobs to the MCP Profile Hub system profiles, explains why the narrow ones work better, and covers when to build your own.
If you haven't connected anything yet, start with set up your AI workbench for Contentstack.
The short version
Start with Content Explorer. It is read-only, and it answers most "what's in this stack" questions.
Use a job profile, such as Entry Author, Publishing Helper or Launch Deploy Helper, when you need to change something.
Keep the product profiles (CMS, Launch, Personalize and the others) for people who really need full control of that product. They include destructive tools.
Build a custom profile when a job needs one tool a system profile leaves out.
A profile never grants more than your role. Destructive tools are marked, and clients ask before running them.
Job to profile
These are the system profiles I reach for, with the profile_id you can put on the connector URL.
The job | Profile | profile_id | Can it change anything? |
|---|---|---|---|
Find out what content types, entries and assets exist | Content Explorer | content_explorer | No |
Read the content model to write code or docs | Content Modeler | content_modeler | No |
Check what visitors actually get from the Delivery API | Published Content QA | published_content_qa | No |
Find broken or orphaned references before a release | Broken Reference Checker | broken_reference_checker | No |
Find entries missing a translation | Localization Gap Finder | localization_gap_finder | No |
See who changed what and when | Governance Inspector | governance_inspector | No |
Draft or edit entries | Entry Author | entry_author | Creates and updates drafts, never publishes |
Publish or unpublish prepared content | Publishing Helper | publishing_helper | Publishes, doesn't edit |
Ship a set of changes together | Release Manager | release_manager | Creates and deploys releases |
Clean up taxonomies and terms | Taxonomy Librarian | taxonomy_librarian | Creates, moves and deletes terms |
Tidy asset titles, tags and folders | Asset Librarian | asset_librarian | Updates metadata, can't delete or publish |
List deployments, read build logs, redeploy | Launch Deploy Helper | launch_deploy_helper | Triggers deployments and cache revalidation |
Watch API and CDN traffic, status codes and cache hits | Delivery Analytics | delivery_analytics | No |
A few of these pair up well. Entry Author writes drafts and Publishing Helper takes them live, so the agent that drafts can't also publish. Content Modeler compares content types and global fields between branches, which is what I want open next to a branch-based model change.
Why narrow beats broad
The CMS profile has over a hundred tools. Content Explorer has eight. For a question like "which content types reference the author type", both get you there, but they don't get you there the same way.
The agent picks the wrong tool less often. With eight tools there is little to confuse. With a hundred, many tools sound alike: list entries, get one entry, get its references, get its versions, get its variants. The Profile Hub docs say it plainly: smaller and older models misread tool descriptions more often.
Every request carries less. Tool definitions go into the context on every turn. In the evaluation behind how MCP Profile Hub enriches tools for your stack, 77 CMA tools took about 10,000 tokens of tool definitions per request before enrichment. Eight tools take a fraction of that, which leaves room for your actual content.
Mistakes stay small. A read-only profile can't delete an entry because the tool isn't there. That's a stronger guarantee than hoping the model reads the confirmation prompt the way you meant it.
Enrichment stays focused. Profile Hub fills each tool with your stack's content types, locales and branches, but only for the products the profile uses. A narrow profile gets short, exact enums instead of every value from every product.
None of this makes the product profiles bad. If you are the platform admin and you need to restructure a stack, the CMS profile is the right tool. It's the wrong default.
When to build your own
Build a custom profile in the MCP Profile Hub app when a system profile is almost right but misses one piece. Two examples I run into:
Runtime logs for a Launch deployment. Launch Deploy Helper reads build logs, but not server logs. The full Launch profile has server logs, but also deletes projects and environments. A custom profile with Deploy Helper's tools plus the server log tool is the narrow version of what I want. I use exactly that setup in debug a failing Launch deploy with an agent.
A workflow across two products. Campaign Go-Live already combines publishing an entry with revalidating the Launch cache. If your flow is different, for example publishing a release and then revalidating, build a profile for that flow rather than connecting two product profiles.
Some rules I follow when I build one:
One profile per job. A second focused profile is better than one profile that does two jobs.
Pick tools by operation. The catalog tags every tool as Read, Create, Update, Delete, Action or Publishing, so you can see at a glance what you're adding.
Fewer tools mean fewer OAuth scopes. Profile Hub derives the scopes from the tools you pick, so a read-only profile only asks for read scopes.
Set the stack, and for write profiles a branch, in the profile's configuration. Then the agent doesn't have to ask, and it can't guess wrong.
The destructive-tools rule
Every tool tells your client whether it only reads, changes something, or removes something. A tool counts as destructive when it deletes data, replaces it, or changes something live: publishing, a Launch deployment, a cache purge. Clients such as Claude Code use that mark to ask you before running the tool, and run read-only tools without asking.
That prompt is a hint for your client, not a permission system. Two things actually limit what happens:
The profile. If the tool isn't in the profile, the agent can't call it.
Your role. Every call runs with your own Contentstack account. If your role can't publish to production, the call fails, whatever profile you use.
So my rule is: if a job doesn't need a destructive tool, connect a profile that doesn't have one. If it does, read the confirmation before you approve it, and check which stack, branch and environment it names.
Concluding
Pick the profile for the job you're doing right now, not for every job you might do later. Content Explorer for looking around, a job profile for changing something, a product profile only when you need the whole product. If the agent needs one tool more, build a custom profile with that tool added instead of jumping to the broad one.
Frequently asked questions
Which Profile Hub profile should I start with?
Content Explorer. It is read-only and covers content types, entries, assets and locales, which is enough for most questions about a stack.
Why not just use the CMS profile for everything?
It exposes the full CMS toolset, over a hundred tools including delete and publish. The agent picks the wrong tool more often, every request carries more tool definitions, and a mistake can change live content.
When should I build a custom profile?
When no system profile matches the job, for example when a job needs one tool a system profile leaves out, or spans two products in a way no system profile does.
Can a profile let the agent do more than my role allows?
No. Every call runs with your own Contentstack roles. A profile can only narrow what the agent can do.