AutoGineer
Generated banner for Add Agent Playbooks
Generated logo for Add Agent Playbooks

Add Agent Playbooks

RedisOfficialCreated by redis

  • Skill
  • Workflow
  • Automation and integrations
  • MIT
  • No issues found
Download ZIP

From the author

Add Redis Iris Agent Playbooks to an existing agent. Use when approved answers or repeatable procedures live in prompts, document retrieval, or a semantic response cache. Connect or provision a Playbook, publish FAQs and Skills, and verify the first application turn with optional review proposals.
— the description by redis

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured workflow for migrating existing agent prompts, document retrieval, or semantic caches into Redis Iris Agent Playbooks. It guides developers through orienting their current agent architecture, provisioning the necessary infrastructure, authoring and publishing content (FAQs and Skills), and integrating these components into the application runtime. The process emphasizes verifying agent behavior through controlled application turns, ensuring that approved answers and procedures are correctly loaded and executed.

What it does

  • Maps existing agent tasks and answers to structured Playbook Skills and FAQs.
  • Provides commands to validate, plan, and sync content files for deployment.
  • Guides the integration of Playbook context objects into Python agent runtimes.
  • Facilitates verification of agent turns to ensure content is correctly retrieved and followed.
  • Supports the implementation of review proposals for uncovered agent queries.
  • Assists in cleaning up obsolete prompt-based logic after successful migration.

When to use it

  • When you need to move hardcoded procedures or answers out of prompts into a managed system.
  • When implementing a semantic response cache for an existing agent.
  • When you need to standardize agent behavior across multiple audiences.
  • When you want to enable a review process for agent responses to uncovered queries.

Advantages

  • Decouples business logic and approved answers from the agent's core prompt.
  • Enables versioned management of agent procedures and FAQs.
  • Supports audience-specific content delivery via attributes.
  • Provides a clear path for verifying and debugging agent turns.

Usage examples

“How do I start migrating my agent's refund procedure to a Playbook?”
The agent will guide you through creating a new Skill directory, defining the procedure in a Markdown file, and using the CLI to validate and sync the content.
“I need to add an FAQ for our shipping policy to my existing agent.”
The agent will help you format the FAQ as a JSON entry, validate it against your project structure, and publish it to the active environment.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/redis/add-agent-playbooks/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip add-agent-playbooks.zip -d .agents/skills

Documentation by redis

Add Agent Playbooks

Bring an existing Python agent to one verified Playbook-backed turn, then finish the requested content migration or integration. FAQs supply published answers; Skills supply procedures loaded separately from discovery previews. The application owns response policy, tool permissions, and approval of actions.

1. Orient and choose the behavior

Find the model call, tool registration, framework/version, and existing policy or procedure sources. Preserve the graph, business tools, and global response/authorization rules. Infer these decisions from the request and code; ask only about unresolved choices and state defaults used:

DecisionResult
Which repeated tasks need procedures?One Skill per procedure; skip when none. Move task-specific tool guidance out of prompts.
Which questions require approved answers?One FAQ per approved answer; skip when none.
Which audiences use the content?One audience: no attribute or filter. Several: matching attributes on content and a trusted runtime audience.
Should uncovered answers be submitted for review?Default no. Yes: choose automatic uncovered proposals or an application-owned quality/privacy gate; preserve existing gates.
Where does the content live today?Convert relevant prompt text, docs, or retrieved content into versioned files. Retain authoritative sources.

Prefer progressive disclosure when the agent can execute tools; use score-based hooks otherwise. Define clarification, escalation, and outage behavior: approved-only answers need an explicit policy for insufficient content.

2. Check prerequisites and connect

Follow provisioning for the short prerequisite check and new, partial, or existing setup. Reuse usable configuration and published content. Local defaults require a running stack; Cloud and self-managed administration use different paths.

Check framework APIs against the installed version before editing. Use an available docs MCP. For the CLI, run iris agent-playbooks <command> --help. Inspect installed package source when documentation does not match the installed API. Report unresolved compatibility questions.

3. Publish the first relevant content

Follow content authoring for file formats, quality checks, audience attributes, validation, previews, and publication. Begin with one approved FAQ or procedure relevant to the requested task; use both only when needed. Confirm its serving version before wiring the agent. Complete any broader requested migration after the first turn works.

4. Integrate with the application

Follow runtime integration for the chosen mode, async variants, and framework placement. Create one configured context object and use it throughout. Build context from the base prompt afresh each turn. Register disclosure tools with both the model and executor.

5. Run, inspect, and improve

Follow first success: execute the actual application, inspect the content keys/versions and procedure loads, check a paraphrase and missing-content behavior, fix observed gaps, and rerun. Show the user what worked and how to repeat it. Once replacement reads work, remove obsolete runtime prompt/retriever/cache code and its unused embedding pipeline; run affected application checks on the final integration.

6. Hand off and maintain

Use the handoff in first success to distinguish observed results from unverified work and leave an exact repeat command. Walk through the next approved content update, naming the content owner/publisher and any remaining deployment configuration.

Essential constraints and optional paths

  • Every iris command uses root options --json --no-input. The CLI handles administration and content management; the Python SDK runs inside the application.

  • Keep runtime .env credentials separate from .env.content publishing credentials and administrative tokens. Grant the agent read, adding propose only for submissions. Never print secrets or commit env files.

  • Publication selects serving content. A proposal is a review candidate; submitting or accepting one does not implicitly publish it.

  • For a semantic response cache, read cache migration before replacing its lookup/write path.

  • For background proposals from Agent Memory, read Memory extraction before enabling another submission path.

Files

references/first-success.md

Verify the first application turn

Read this after the chosen content is published and the application is wired. For an existing integration, verify the changed behavior and reuse the working parts. This is the application verification loop; deployment checks belong to provisioning, and content commands belong to authoring.

Select one useful scenario

Use an approved example from the actual application. Record the expected content key, serving version, and observable behavior before running it. Reuse the application's launcher, test client, or endpoint; record the exact invocation and required env-file names without secret values. A standalone SDK discovery call verifies retrieval only.

With the illustrative content in the authoring reference, a useful scenario is:

CaseQuestionExpected evidence
DirectHow do I request a refund?refund-request appears at its serving version; the response uses its approved guidance. If refund intake is also selected, its procedure is loaded before following the steps.
ParaphraseWhat details do you need to give me my money back?The same relevant guidance is available despite different wording.
UncoveredCan you approve a mortgage for me?The application's agreed clarification/escalation response; no invented policy or unsupported action.

Replace these with project-specific questions and expected keys. Test only the content types configured. With multiple audiences, also verify that the application's trusted audience selects the intended content.

Execute, inspect, correct, repeat

  1. Run the actual application path. For a procedure, execute the model/tool loop far enough to observe loading and the next required step. Use a harmless scenario that fits the application's authorization rules.

  2. Inspect the evidence. Record discovered keys, serving versions, and scores. For hooks, confirm the above-threshold procedure reached the actual prompt. For disclosure, inspect the executed load_skill key/version and tool result, including resource reads if needed. Use existing trace facilities when available; otherwise inspect the prompt/tool results through the application's test/debug path.

  3. Judge the response against the selected source. Check that it quotes the approved facts or follows the loaded steps and respects the missing-content policy. A retrieved preview does not prove a procedure was followed. Capturing a prompt/tool trace proves wiring; evaluating model behavior requires a real model run.

  4. Fix observed gaps, then rerun the affected case. Use the table below. Keep the original framework and business tools. Once the direct case works, run its paraphrase and uncovered case. Record the outcome of each; do not round partial verification up to success.

ObservationInspect or correct
Content absentServing publication, exact audience/filter attributes, query relevance, discovery thresholds, and truncated/budget_truncated. An identical draft needs explicit publication.
Irrelevant content returnedDescription/question/intents, filters, scores, and application relevance handling. Choose thresholds from representative results. noop local embeddings cannot establish semantic retrieval quality.
Menu present, procedure absentHooks threshold; for disclosure, model instructions and registration of the same tools with the model and executor.
Old context persistsRebuild from the base prompt; verify the adapter replaces its context message and loads the menu's version.
Unsupported answerMissing-content response policy and the application's acceptance gate. Publication controls retrieval, not every claim a model generates.
Agent call failsSDK/CLI version, env loading before initialization, URL, permissions, and the actual failing operation; use provisioning's deployment-specific checks.

If automatic proposals are enabled, inspect the receipt/inbox after an uncovered answer. Replay the identical candidate to verify deduplication; another model-generated answer can legitimately create another proposal. Preserve application-owned gates and keep this check out of serving publication.

For missing-configuration handling, use a fresh object/test process with the ID or agent key omitted: the first remote operation must name the missing setting. The constructor is lazy and the URL has a localhost default. Keep the running application's environment intact.

If credentials, services, or a model are unavailable, finish the local work and report the precise missing prerequisite. Deterministic model/HTTP fixtures can verify wiring and requests; label them as offline rehearsals. Keep live retrieval quality, real model behavior, and production verification unconfirmed until observed.

Handoff

Show the user the result and how to operate it. Use actual values from the run:

  • Connected: deployment/profile and Playbook ID; content source files and runtime integration locations.

  • Observed: question, discovered key/version, loaded procedure/version when applicable, and the relevant response or next procedural step. Include a verified UI/trace link when available; otherwise name the CLI inspection command.

  • Repeat: the exact application invocation and env-file names. For an interactive app, include the request or question to submit.

  • Ownership: who edits the content and which existing person/process publishes it. Preserve established ownership; ask if it cannot be established.

  • Next update: the approved edit/validate/preview/publish/verify path from content authoring.

  • Remaining: offline versus live checks, unresolved prerequisites, and production runtime variables or content-publishing configuration still to supply. Prepare requested configuration changes using the project's deployment conventions; deploy only within the user's authorization.

For example, after observing it: “Your application answered the refund question using refund-request v1 and loaded refund-intake v1. Here is the response, the repeat command, and where to update the content.” Omit unsupported parts of that statement when only one content type or an offline rehearsal was verified.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
redis
Publisher
Redis (Official)
Source
redis/agent-skills · skills/add-agent-playbooks · commit 74708da
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Also distributed in
redis/agent-skills

AutoGineer is not affiliated with or endorsed by redis.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download add-agent-playbooks.zip