Skip to main content
Prompt management is the practice of treating the prompts you send to a model the way you already treat code that ships to production: keep them in one place, version every change, and know which version is live. to11 does this for the prompts your project owns: you author them in the dashboard, and your application renders the newest version at runtime through an SDK.

Why prompts don’t belong in your code

Most LLM features start with the prompt written inline, right next to the call to the model:
That works until it doesn’t. The prompt is the part of an AI feature you tune most often, yet burying it in code means:
  • Every wording change is a code change: a pull request, a build, a deploy, all for a tweak a product manager could have made in a text box.
  • There’s no history. You can’t see what the prompt said last Tuesday, who changed it, or why the quality dropped after the change.
  • You can’t compare two versions without digging through commits.
  • Only engineers can touch it, even though the people who understand the prompt best often aren’t engineers.
Prompt management pulls the prompt out of the binary and puts it behind a versioned surface. The same feature now renders its prompt:
The application no longer contains a single line of prompt text. Changing the prompt (fixing a phrasing, adding an example, tightening a rule) is now an edit-and-publish in the dashboard, not a redeploy. See Rendering prompts for the full runtime side.

How to11 models a prompt

A prompt is a named, versioned template that a project owns, alongside that project’s skills, environments, and sessions. It has a stable slug (weather-concierge) your application renders by, and a history of versions behind it.
There are two kinds of prompt. This page describes a chat prompt, which your application renders into messages and sends to a model. The other kind is a skill — a folder of files delivered to a developer’s machine, where a coding agent reads it. Both use the same versions, the same latest label and the same history; what differs is what they carry and who they are handed to. A prompt’s kind is chosen when it is created and never changes. Skills have their own section, starting at Skills.
A version is one immutable snapshot of the template. It carries everything needed to render the messages the model sees: Authoring happens on a draft. Publishing freezes the draft into a read-only version, moves the prompt’s one label, latest, to it, and starts a fresh draft from the same blocks, so what’s live never changes underneath you. See Versions.

Message roles

Each block is a message with a role that tells the model who is speaking and how much authority the message carries. system and developer are the author’s roles, and they outrank the end user’s user messages, so a rule you set isn’t overridden by what a user types. assistant blocks and tool-result blocks stand in for earlier turns in the conversation. The Authoring page describes what each role is for; how a developer block reaches a model that doesn’t accept that role is covered under Rendering.

to11 serves the prompt; your code sends the call

to11 keeps the prompt and hands it to your application; it is not part of the model call itself:
  • to11 (the dashboard and the SDK’s prompts.* methods, backed by the to11 API) is where you author and publish versions, and where your application renders one.
  • Your provider client (the OpenAI or Anthropic SDK, or any other) sends the rendered messages, tools, and model settings to the provider, with your own provider key.
So the version you published is exactly the version your application renders, and adopting prompt management changes where the prompt comes from, not how you call your model. The SDK shapes the rendered prompt for the OpenAI and Anthropic clients so it can be passed straight in; see Rendering prompts.

The lifecycle

  1. Author. Build the version’s blocks, variables, tools, and config in the editor. See Authoring.
  2. Publish. Freeze the draft into an immutable version; latest moves to it. See Versions.
  3. Render. Your application renders latest, which is always the newest version. See Rendering prompts.

Next steps

Authoring prompts

Blocks, variables, conditions, tool definitions, and model config.

Versions

Publish immutable versions; latest follows the newest.

Rendering prompts

Render a prompt’s newest version from your application at runtime.