Prompt management

Centralized system prompts, templates, and format contracts—versioned, reviewed, and rolled out without redeploying every agent.

Marketing: exemplar.dev/marshal/prompt-management .

When to use it

Keep role instructions and output contracts consistent across frameworks and channels instead of scattering prompt text in IDE configs and repos.

Where in Console

Create or update templates in Marshal prompt surfaces; validate format before promotion; gate risky changes with evals.

Use from SDK and CLI


from exemplar_harness import Harness
 
prompts = Harness.from_env().prompts()
prompts.create(
    name="support-summary",
    title="Support summary",
    messages=[
        {"role": "system", "content": "Be concise."},
        {"role": "user", "content": "Summarize topic: {{topic}}."},
    ],
    variables=["topic"],
)
built = prompts.build("support-summary", variables={"topic": "returns"})
result = prompts.run("support-summary", variables={"topic": "returns"})


exemplar prompts create support-summary \
  --title "Support summary" \
  --system "You are a concise support agent." \
  --user "Summarize topic: {{topic}}." \
  --variables topic
exemplar prompts build support-summary --var topic=returns
exemplar prompts run support-summary --var topic=returns

API	Use when
`build` / `build()`	Local `{{var}}` substitution — hand messages to your agent / SDK
`run` / `run()`	Execute the stored prompt via Exemplar (gateway-backed model)
`run_inline`	One-off messages without a stored prompt

Full patterns: SDK client usage · CLI.

Framework / SDK examples

Prefer build for frameworks: substitute variables once, then pass system/user text into the agent. Use run when Exemplar should call the model for you.

Agno — build, then run agent


pip install "exemplar-harness-sdk[agno]"


from agno.agent import Agent
from agno.models.openai import OpenAIChat
from exemplar_harness import Harness
 
harness = Harness.from_env()
built = harness.prompts().build("support-summary", variables={"topic": "returns"})
 
system = next((m["content"] for m in built.messages if m["role"] == "system"), "")
user = next((m["content"] for m in built.messages if m["role"] == "user"), "")
 
agent = Agent(
    name="support-bot",
    model=OpenAIChat(id="gpt-4o-mini"),
    instructions=[system] if system else None,
)
agent.run(user)

LangChain — built messages


pip install "exemplar-harness-sdk[langchain]"


from langchain_core.messages import HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI
from exemplar_harness import Harness
 
harness = Harness.from_env()
built = harness.prompts().build("support-summary", variables={"topic": "returns"})
 
messages = []
for m in built.messages:
    if m["role"] == "system":
        messages.append(SystemMessage(content=m["content"]))
    elif m["role"] == "user":
        messages.append(HumanMessage(content=m["content"]))
 
ChatOpenAI(model="gpt-4o-mini").invoke(messages)

OpenAI SDK — build or run


pip install "exemplar-harness-sdk[openai]"


from openai import OpenAI
from exemplar_harness import Harness
 
harness = Harness.from_env()
prompts = harness.prompts()
 
# A) Your model, Exemplar template
built = prompts.build("support-summary", variables={"topic": "returns"})
OpenAI().chat.completions.create(model="gpt-4o-mini", messages=built.messages)
 
# B) Exemplar runs the stored prompt (gateway)
result = prompts.run("support-summary", variables={"topic": "returns"})
print(result["content"])

TypeScript — build into OpenAI / Agents


import OpenAI from "openai";
import { Harness } from "@exemplar-dev/exemplar-harness-typescript-sdk";
 
const harness = Harness.fromEnv({ agentId: "support-bot" });
const built = await harness.prompts().build("support-summary", {
  variables: { topic: "returns" },
});
 
const client = new OpenAI();
await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: built.messages as OpenAI.Chat.ChatCompletionMessageParam[],
});


import { Agent, run } from "@openai/agents";
import { Harness } from "@exemplar-dev/exemplar-harness-typescript-sdk";
 
const harness = Harness.fromEnv({ agentId: "support-bot" });
const built = await harness.prompts().build("support-summary", {
  variables: { topic: "returns" },
});
const system = built.messages.find((m) => m.role === "system")?.content ?? "";
const user = built.messages.find((m) => m.role === "user")?.content ?? "";
 
const agent = new Agent({
  name: "support-bot",
  instructions: String(system),
});
await run(agent, String(user));

Publish a version, then build


prompts = Harness.from_env().prompts()
prompts.publish_version(
    "support-summary",
    messages=[
        {"role": "system", "content": "Be concise."},
        {"role": "user", "content": "Bullet summary for: {{topic}}."},
    ],
    change_notes="Use bullets",
)
built = prompts.build("support-summary", variables={"topic": "returns"})

Gate promotions with Evals (Insights + Session Evals on ingested agent runs).

Runnable sample: platform/prompts.py · catalog Live SDK examples.

Related: Skill management · AI Gateway · Client usage.