From rierino-development
GenAI agent record generator for the Rierino core platform. Translates a user's natural-language requirements — the agent's role, purpose, desired behavior, and model settings — into a single production-ready, schema-compliant agent configuration JSON object. The generated record is fully populated with model parameters, memory strategy, tool sagas, a complete set of proportional guardrails, and a specialist system prompt written directly to the agent. Use this skill whenever the user asks to create, modify, debug, or improve a GenAI agent, assistant, bot, copilot, or LLM-backed system prompt — even if they don't say "agent" explicitly but the context involves configuring an LLM to play a role, follow instructions, call tools, or run inside the Rierino platform. Also trigger when the user mentions agent instructions, guardrails, risk policies, tool sagas, memory strategy, or model settings (model name, temperature, response format).
How this skill is triggered — by the user, by Claude, or both
Slash command
/rierino-development:ai_agent_assistantThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
GenAI agent record generator for the Rierino core platform. Translates a user's natural-language requirements — the agent's role, purpose, desired behavior, and model settings — into a single production-ready, schema-compliant agent configuration JSON object. The generated record is fully populated with model parameters, memory strategy, tool sagas, a complete set of proportional guardrails, an...
GenAI agent record generator for the Rierino core platform. Translates a user's natural-language requirements — the agent's role, purpose, desired behavior, and model settings — into a single production-ready, schema-compliant agent configuration JSON object. The generated record is fully populated with model parameters, memory strategy, tool sagas, a complete set of proportional guardrails, and a specialist system prompt written directly to the agent. Use this skill whenever the user asks to create, modify, debug, or improve a GenAI agent, assistant, bot, copilot, or LLM-backed system prompt — even if they don't say "agent" explicitly but the context involves configuring an LLM to play a role, follow instructions, call tools, or run inside the Rierino platform. Also trigger when the user mentions agent instructions, guardrails, risk policies, tool sagas, memory strategy, or model settings (model name, temperature, response format).
[!IMPORTANT] Naming Standards: All data paths, identifiers, and property keys must follow
CONVENTIONS.MD.
Before generating any agent that uses tools, you must fetch the catalog of sagas (flows that can be used as tools in Rierino) available. Always start by retrieving the available sagas. If the user specified any specific runner for the AI agent, filter these sagas using the runner from the agent's allowedFor array.
Use the appropriate tool with the following calls:
| Resource | Call | Returns |
|---|---|---|
| Saga Catalog | List sagas available for AI agents | Saga id, data.name, data.description, and data.steps — used to populate data.parameters.toolSagas |
| Existing Agent | Read an existing agent by ID | The current agent record, when modifying or improving an agent rather than creating one |
Rules:
id values returned from the catalog. If none apply, use [].State_Get_genai_model_write tool on the rierino MCP server to read an existing agent for a mentioned role or flow.Saga_sagas tool on the rierino MCP server to fetch the available saga catalog when you need valid IDs for toolSagas. This is only required if the user wants the agent to execute some actions as tools.${RIERINO_UI_BASE_URL}/app/ds/common/genai_model?id={id} unless you deleted it.You are an expert SQL engineer. Always validate SQL before responding.This agent acts as a SQL engineer. The agent should validate SQL before responding.Every agent must be a single JSON object with this structure:
{
"id": "string — unique identifier, recommended format {role}_assistant (e.g. sales_assistant)",
"data": {
"name": "string — human-readable agent name (e.g. Sales Assistant)",
"description": "string — one-paragraph summary of the agent's purpose",
"tags": ["string — relevant tags (e.g. sales, crm, customer-support)"],
"version": "string — version string, default \"0\"",
"status": "string — agent status, default \"A\"",
"domain": "string — the folder the agent lives in (e.g. development, training, content)",
"allowedFor": ["string — runner IDs the agent runs on; leave empty unless specified by user"],
"icon": "string — agent icon; leave empty unless specified by user",
"parameters": {
"class": "string — component type, default io.rierino.rai.openai.OpenAiChatModel",
"methods": "object — model configuration (see methods default)",
"memory": "string — state to store memory in, default genai_memory",
"toolSagas": ["string — saga IDs the agent may execute for custom business flows"],
"guardrails": "object — guardrails configuration (see Guardrails)",
"instructions": "string — production-ready specialist system prompt (see Generated Instructions)"
}
}
}
id using the recommended format {role}_assistant (e.g. sales_assistant) unless the user provides one.id, do not change its value.data.parameters.methods defaultFor the default io.rierino.rai.openai.OpenAiChatModel class, the following default values should be used. If the user specifies a different chat model class, leave empty:
{
"apiKey": "#{{rierino.system.openai.apikey}}",
"model": "gpt-5.4",
"temperature": "1"
}
NOTE: io.rierino.rai.openai.OpenAiChatModel can be used by any provider that has OpenAI compatible APIs. For non OpenAI providers, you need to add a baseUrl parameter to methods, which should point to the OpenAI compatible base URL of such provider.
Guardrails prevent prompt injection and jailbreaks, prevent sensitive-data leakage, protect and validate tool execution, enforce domain-specific safety, and reduce hallucinations in high-risk domains. Keep them proportional: lightweight for simple informational agents, stronger for tool-enabled and business-critical agents. Prefer masking over blocking when safe, and REPROMPT over BLOCK for recoverable output issues.
Always generate this complete structure:
{
"riskPolicy": {
"blockOnLevelCounts": "object - key-value pairs identifying how many rules should be triggered per risk level to block a content",
"criticalAutoBlock": "boolean - whether CRITICAL findings should always block"
},
"inputGuardrails": ["object - list of rules to apply on user sent messages - e.g. for protecting against prompt injection"],
"toolResponseGuardrails": ["object - list of rules to apply on tool generated responses - e.g. to mask sensitive data from data tools"],
"outputGuardrails": ["object - list of rules to apply on AI generated messages - e.g. to block AI from generating irrelevant / unsecure response"]
}
Each guardrail can be configured to apply a specific restriction on its input:
| Action | When to use |
|---|---|
BLOCK | Severe violations; CRITICAL and (typically) HIGH findings |
MODIFY | When the offending information can be safely masked |
REPROMPT | Recoverable output issues the model can fix on a second pass |
Each guardrail type can be configured to include multiple entries for protecting against malicious inputs, outputs and tools. While Rierino provides a flexible set of configurations for guardrails, always use the following as the starting point for the users:
{
"riskPolicy": {
"blockOnLevelCounts": {"MEDIUM": 3, "HIGH": 2},
"criticalAutoBlock": true
},
"inputGuardrails": [
{"type": "regex-matcher", "config":{ "groups": ["jailbreak-basic"] }},
{"type": "regex-masker", "config":{ "groups": ["pii-basic"] }}
],
"toolResponseGuardrails": [],
"outputGuardrails": []
}
For use cases where security and privacy is more important, switch to "-extended" versions of these presets (i.e. pii-extended, jailbreak-extended) and use "CRITICAL" risk level instead.
data.parameters.instructions)Generate a production-ready, specialist system prompt for the requested role and domain. Write directly to the agent. Avoid generic AI-assistant language ("be helpful"); prefer explicit operational rules over descriptions; include domain-specific constraints, output contracts, and validation checklists where appropriate.
Use markdown and follow this section structure as H2 level (don't include any H1):
| Section | Required? | Defines |
|---|---|---|
| Role & Expertise | Mandatory | identity, expertise, specialization, authority |
| Core Behavior | Mandatory | operational behavior using Always / Never / Prefer / Avoid |
| Domain Rules | Mandatory | role-specific operating rules |
| Tool Usage Rules | When tools are relevant | when to use / not use tools, validation, ordering |
| Output Format | When formatting matters | response structure; required and forbidden formatting |
| Validation Checklist | For technical / structured / high-impact output | self-review steps |
| What Not To Do | Mandatory | prohibited behaviors |
| Role | Example domain rules |
|---|---|
| SQL Agent | Prefer ANSI SQL; avoid SELECT *; use explicit JOIN syntax |
| Java Agent | Use Java 21 syntax; prefer records where appropriate; avoid deprecated APIs |
| Content Writer | Write for the target audience; avoid marketing clichés; prioritize clarity |
| JMESPath Expert | Always use supported functions; never invent syntax |
Before returning an agent, verify:
memory is defined.toolSagas is present.icon is present.guardrails object exists and contains riskPolicy, inputGuardrails, toolResponseGuardrails, and outputGuardrails; tool-enabled agents include tool response guardrails; sensitive domains include PII protection; jailbreak protection and a risk policy are always present.If any check fails, repair the object before returning it.
id when modifying a user-provided agent.Provides behavioral guidelines to reduce common LLM coding mistakes, focusing on simplicity, surgical changes, assumption surfacing, and verifiable success criteria.
Searches, retrieves, and installs Agent Skills from prompts.chat registry using MCP tools like search_skills and get_skill. Activates for finding skills, browsing catalogs, or extending Claude.
Creates, edits, and optimizes skills for Claude Code, including drafting, evaluating with test prompts, iterating on performance, and improving skill descriptions for better triggering accuracy.
npx claudepluginhub rierino-open/rierino-claude-plugin