Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Agentic Engineering Patterns Library 💯

    1

    Design reliable, production-ready AI agents using structured engineering patterns and failure-mode analysis.

    $23.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Agentic Engineering Patterns Library 💯

    Agentic Engineering Patterns Library 💯

    Example session with this skill installed

    I need to design a customer support agent that can check order status in a SQL DB and issue refunds. It needs to be reliable and safe. Show me the architecture and patterns.

    • Read your context and instructions
    • Compiled the agentic engineering patterns

    I have analyzed the requirements for a support agent with SQL access and refund capabilities. Given the high consequence of financial transactions, I recommend a

    Supervised autonomy level.

    Agentic Architecture Blueprint: Support & Refunds

    Recommended Patterns

    • Approval Gates: Mandatory human-in-the-loop verification for any refund transaction exceeding $0.

    Tool Result Normalization: SQL outputs are parsed into typed schemas before being passed back to the LLM to prevent injection.

    Idempotency Keys: Every refund request must include a unique order_id + transaction_type hash to prevent duplicate billing.

    Execution Flow

    1. Input Validation: Guardrail check for PII and prompt injection.
    2. Planning: Agent determines if the request requires READ_ONLY (order status) or WRITE (refund) permissions.
    3. Tool Execution:
      • check_order_status: Executes directly via SQL read-only replica.
      • issue_refund: Generates a draft transaction and pauses for human approval.
    4. Verification: System verifies refund eligibility against business rules post-approval.
    5. Reporting: Final status update to the user with a transaction ID.

    Failure Modes & Mitigations

    Failure ModeMitigation
    SQL TimeoutImplement exponential backoff with a 3-retry limit.
    Model hallucinates refundSchema validation on tool calls rejects malformed amounts.
    Duplicate refund clicksDatabase-level unique constraint on refund_request_token.

    Next steps

    • Define the specific SQL schema for the check_order_status tool.
    • Set up the approval queue UI for the support leads.
    • Establish a regression dataset of common support queries to test routing accuracy.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Agentic systems are notoriously unpredictable, prone to infinite loops, and difficult to debug in production. This skill provides a rigorous engineering framework to move beyond basic prompting into structured, reliable agent architectures. It organizes reusable patterns for planning, tool execution, memory management, and multi-agent coordination into a systematic design process.

    What it does

    • Pattern Selection helps you choose between architectures like plan-then-execute, supervisor-worker, or sequential handoffs based on specific constraints.
    • Reliability Engineering provides blueprints for bounded retries, circuit breakers, and idempotency to prevent runaway costs or duplicate actions.
    • Safety & Guardrails designs least-privilege tool access, approval gates for high-stakes operations, and input/output validation strategies.
    • Memory Management structures durable state, RAG-based context retrieval, and compaction techniques to maintain long-running task context.
    • Evaluation Frameworks defines task-level success metrics, failure taxonomies, and regression datasets for offline and online testing.

    How it works

    1. Define the Job: You provide the business outcome, available tools, and reliability constraints to establish a baseline requirements document.
    2. Determine Autonomy: The skill classifies the workflow into assistive, supervised, or bounded autonomous levels to set the safety ceiling.
    3. Map Execution: It generates an end-to-end flow covering state transitions, tool boundaries, and validation gates.
    4. Stress Test: It identifies failure modes (e.g., stale plans, tool timeouts) and provides specific mitigations for each.

    Frameworks & tools

    This skill is platform-agnostic and applies to LangGraph, CrewAI, AutoGen, or custom agent implementations using OpenAI, Anthropic, or local LLMs.

    Why this beats prompting it yourself

    Generic prompts often ignore the operational reality of agentic loops. This skill forces you to address trade-offs between latency and reliability while providing a production-readiness checklist that prevents common deployment failures.

    Use cases

    • Designing a multi-agent system for complex software engineering tasks with human-in-the-loop approvals.
    • Architecting a reliable RAG agent that requires durable memory and source freshness tracking.
    • Building a tool-using agent for database operations that needs strict idempotency and permission boundaries.
    • Auditing an existing agentic workflow to identify risks in error handling and cost management.

    Known limitations

    Does not provide executable code for specific proprietary SDKs. Architectural recommendations are context-dependent and require manual implementation and verification.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Does not provide executable code for specific proprietary SDKs. Recommendations are context-dependent and require manual implementation.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 14 days ago

    Permissions

    No special permissions declared or detected

    Listed14 days ago

    What's inside

    Frequently Asked Questions

    This library provides a systematic framework for designing agent architectures that are resistant to common production issues like infinite loops, high costs, and unpredictable tool outputs. It moves you from experimental prompting to robust engineering by applying proven patterns for memory, safety, and coordination.

    The patterns are platform-agnostic and designed to work across any stack, including LangGraph, CrewAI, and AutoGen, as well as custom-built systems using OpenAI, Anthropic, or local LLM providers.

    You will receive a comprehensive repository of architectural blueprints, safety checklists, failure-mode analysis templates, and decision matrices for selecting the right agentic flow for your specific use case.

    No, this is an architectural design resource; it provides the logic, flow, and structural requirements for your agents, which you then implement using your preferred programming language or SDK.

    This skill is ideal for developers and architects who have an initial agent prototype but are struggling with "hallucination loops," reliability in multi-step tasks, or safely integrating agents with sensitive production tools.

    The library includes a 'Safety & Guardrails' module specifically focused on designing human-in-the-loop approval gates and least-privilege tool access to ensure agents never perform high-stakes actions without authorization.

    New in Agents & Orchestration