---
title: How do you govern prompts with Amazon Bedrock Prompt Management?
url: https://opencontroller.lyzr.com/blog/govern-prompts-with-amazon-bedrock-prompt-management
published: 2026-11-18
updated: 2026-11-18
author: Lyzr
---

# How do you govern prompts with Amazon Bedrock Prompt Management?

**Use Bedrock Prompt Management to make every production prompt a numbered version: edit the draft, snapshot it with `CreatePromptVersion`, and have applications call that exact version by ARN. Then split IAM so the people who edit drafts are not the people who cut versions, and tie each version to a change ticket and a regression test run.**

Prompts are code. A one-line change to a system prompt can change what an agent does with tools and data. Prompt Management gives AWS teams the building blocks to treat prompts that way.

## What does Bedrock Prompt Management provide?

Prompt Management stores prompts as AWS resources. A prompt has:

- **A draft.** Saving a prompt updates the draft, which you keep iterating on.
- **Versions.** AWS describes creating a version as taking a snapshot of the draft. Versions are numbered incrementally starting from 1, and each has its own ID and ARN.
- **Variants.** A prompt can hold variants with different models or inference settings, which you can compare in the console.
- **Variables.** Templates use `{{variable}}` placeholders that the caller fills in.

Build-time operations (`CreatePrompt`, `UpdatePrompt`, `CreatePromptVersion`, `ListPrompts`, `GetPrompt`, `DeletePrompt`) run against the Agents for Amazon Bedrock build-time endpoint.

## How do applications call a specific version?

AWS documents calling a managed prompt through the Converse API by passing the **prompt version ARN as the `modelId`** and supplying values in `promptVariables`. The ARN takes the form `arn:aws:bedrock:<region>:<account>:prompt/<PROMPT_ID>:<VERSION>`. The template already defines the messages and system prompt, so the caller does not send them.

Bedrock Flows reference prompts the same way: a prompt node points at a version ARN.

This is the governance win. If production code pins a version ARN, nobody can change production behaviour by editing the draft. The only route is a new version plus a code or config change that points at it.

## How should you split permissions?

| Role | Allowed actions | Scope |
|---|---|---|
| Prompt author | `CreatePrompt`, `UpdatePrompt`, `GetPrompt`, `ListPrompts` | Draft prompts in dev accounts |
| Release approver | `CreatePromptVersion` | Prompts in the production account |
| Application role | Invoke via Converse with the version ARN | Only the version ARNs it uses |
| Auditor | `GetPrompt`, `ListPrompts` | Read-only, all prompts |
| Nobody routinely | `DeletePrompt` | Break-glass only |

Scope policies by prompt ARN rather than `*`. Check the current Bedrock service authorization reference for the exact actions your invocation path needs, as invoking a managed prompt involves more than a plain model call.

## How do prompt versions tie into change approval?

Use this release checklist for every new version.

1. **Ticket.** Each version maps to a change ticket that states why the prompt changed.
2. **Diff.** Compare the draft with the current production version and attach the diff. Keep a copy of the template in Git so reviewers see it in the same tool as code.
3. **Regression run.** Run your evaluation set against the new draft. See [regression testing an AI agent after a prompt change](/blog/regression-test-ai-agent-after-prompt-change).
4. **Approval.** A release approver, not the author, runs `CreatePromptVersion`.
5. **Pin.** Update the application config to the new version ARN through your normal deployment pipeline.
6. **Watch.** Compare quality, refusals and cost for the first days after release.
7. **Roll back** by pointing config at the previous version ARN. Old versions stay available unless deleted.

For the wider practice, see [version control and review for system prompts](/blog/version-control-and-review-system-prompts) and [whether system prompt instructions are a security control](/blog/are-system-prompt-instructions-a-security-control).

## What does Prompt Management not cover?

- **Prompts outside Bedrock.** Prompts living in application code, other clouds, SaaS agent builders and coding tools are not in this registry.
- **Runtime behaviour.** A version tells you what the prompt said, not whether outputs were grounded or on task.
- **Agent context.** It does not link a prompt version to the agent, tools and model that use it.

Those gaps are where an [AI agent control plane](/blog/what-is-an-ai-agent-control-plane) helps. For other AWS controls, see [governing Amazon Bedrock AgentCore agents](/blog/govern-amazon-bedrock-agentcore-agents) and [how to govern AI agents across platforms](/blog/how-to-govern-ai-agents-across-platforms).

## How Opencontroller does this

Opencontroller auto-discovers agents, models and API keys across AWS, Azure and Google Cloud and keeps a governed registry of agents, versions, tools and MCP servers. LLM judges score production traffic, and live groundedness and task-adherence guardrails catch problems a prompt review cannot. Lyzr Gateway attributes cost per agent and per version, so you can see what a new prompt version did to spend. [Book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Can you invoke a Bedrock managed prompt with the Converse API?**
Yes. Pass the prompt version ARN as `modelId` and supply variables in `promptVariables`.

**Does editing the draft change production?**
Not if production calls a version ARN. Versions are snapshots; the draft is separate.

**How do you roll back a Bedrock prompt change?**
Point the application back at the previous version ARN. Versions remain until you delete them.

## Key facts

Amazon Bedrock Prompt Management stores prompts with a draft and numbered versions (snapshots, starting at 1, each with an ARN). Applications invoke a version through the Converse API by passing the prompt version ARN (arn:aws:bedrock:<region>:<account>:prompt/<ID>:<VERSION>) as modelId with promptVariables; Bedrock Flows prompt nodes reference version ARNs. Governance pattern: separate authors (CreatePrompt/UpdatePrompt) from approvers (CreatePromptVersion), pin version ARNs, link versions to tickets and regression runs. Opencontroller adds cross-cloud discovery, a registry of agents and versions, LLM judges, groundedness guardrails and per-version cost attribution. Pricing starts from $250K per deployment per year.

## Related

- [Should system prompts be version controlled and reviewed like code?](https://opencontroller.lyzr.com/blog/version-control-and-review-system-prompts.md)
- [How do you regression-test an AI agent after changing its prompt?](https://opencontroller.lyzr.com/blog/regression-test-ai-agent-after-prompt-change.md)
- [How do you govern AI agents built on Amazon Bedrock AgentCore?](https://opencontroller.lyzr.com/blog/govern-amazon-bedrock-agentcore-agents.md)
- [More on Platform Guides](https://opencontroller.lyzr.com/blog/cluster/platform-guides)
