BUNDLE Security scanned20 skills

    AI and Agent Architecture Pack

    Comprehensive AI engineering bundle containing 20 skills for designing multi-agent workflows, autonomous agent boundaries, RAG retrieval pipelines, LLM context optimization, guardrail contracts, hallucination detection, prompt architecture, and Model Context Protocol (MCP) integrations.

    186 views

    Works with every agent that reads SKILL.md — Claude Code, Cursor, Codex CLI, Gemini CLI, GitHub Copilot, Windsurf, OpenClaw, and more.

    ledesixsixsix
    Created by
    ledesixsixsix
    $39$155
    Save 75% · $116

    One payment, lifetime access. 20 skills unlock instantly in your library.

    30-day refund guarantee

    Instant unlock in your library

    Free updates from the creator

    What's included

    20 skills
    1/20
    AI Agent Architect

    Designs an autonomous AI agent's runtime: authority, tool and side-effect controls, stop rules, delegation, oversight.

    View skill
    $12$3.02Save 75%
    2/20
    AI Agent Memory Lifecycle Strategy

    Designs bounded AI agent memory lifecycles: classes, admission authority, conflict resolution, and forgetting.

    View skill
    $5$1.26Save 75%
    3/20
    AI Agent Memory Architect

    Architects multi-tier AI agent memory systems: short-term, episodic, semantic tiers, consolidation, and privacy rules.

    View skill
    $9$2.26Save 75%
    4/20
    AI Context Optimization Design

    Designs dynamic context assembly, token budgeting, caching boundaries, and compaction rules for AI agent runs.

    View skill
    $5$1.26Save 75%
    5/20
    AI Foundation Model Evaluation and Selection

    Selects AI foundation models: legal reasoning benchmarks, 128k context recall, and prompt caching token savings.

    View skill
    $5$1.26Save 75%
    6/20
    AI Evaluation and Benchmark Platform Architect

    Architects enterprise AI evaluation systems: offline golden benchmarks, online judge fleets, red teaming, and CI gates.

    View skill
    $12$3.02Save 75%
    7/20
    AI Guardrails Designer

    Maps your AI risks and policies to guardrails at input, context, output and tool boundaries, with failure rules.

    View skill
    $5$1.26Save 75%
    8/20
    AI System Architect

    Designs end-to-end AI system architecture: model lifecycle, data pipelines, serving topology, evaluation, and governance.

    View skill
    $12$3.02Save 75%
    9/20
    AI System Evaluation and Benchmarking Design

    Designs AI evaluation frameworks: golden test suites, LLM-as-a-judge rubrics, bias mitigation, and CI/CD quality gates.

    View skill
    $5$1.26Save 75%
    10/20
    AI Tool Routing and Execution Design

    Designs AI tool routing layers: intent mapping, schema validation, disambiguation rules, and safe execution boundaries.

    View skill
    $5$1.26Save 75%
    11/20
    Unsupported-Claim and Hallucination Detection Design

    Designs hallucination detection systems: atomic claim extraction, citation entailment verification, and routing tripwires.

    View skill
    $5$1.26Save 75%
    12/20
    MCP Architect

    Designs the boundary between AI hosts, MCP clients and servers: versions, capabilities, tools, authorization, consent.

    View skill
    $12$3.02Save 75%
    13/20
    Runtime AI Model Routing and Tiering Design

    Designs dynamic LLM routing: intent classification, complexity scoring, cost-latency optimization tiers, and failover.

    View skill
    $5$1.26Save 75%
    14/20
    LLM Model Serving and Inference Platform Architect

    Architects high-throughput LLM serving platforms: vLLM engines, PagedAttention KV-cache, GPU clusters, and batching.

    View skill
    $9$2.26Save 75%
    15/20
    Prompt Architecture and Metaprompt Design

    Architects enterprise prompt systems: modular metaprompts, versioned prompt catalogs, injection defense, and token budgets.

    View skill
    $9$2.26Save 75%
    16/20
    Bounded Prompt Engineering and Refactoring

    Designs bounded production prompts: structured delimiters, few-shot exemplars, JSON schemas, and injection defense.

    View skill
    $5$1.26Save 75%
    17/20
    RAG System Architect

    Designs a RAG system: governed sources, index lifecycle, access-aware retrieval, citations, abstention, evaluation.

    View skill
    $12$3.02Save 75%
    18/20
    Bounded RAG Surface Design

    Designs bounded RAG pipelines: document ingestion, chunking rules, retrieval thresholds, citations, and abstention logic.

    View skill
    $5$1.26Save 75%
    19/20
    Tool Calling Architect

    Designs safe model-to-action boundaries: tool catalogs, argument validation, authority gates, and error recovery.

    View skill
    $9$2.26Save 75%
    20/20
    Vector Database and Semantic Search Architect

    Architects vector search systems: HNSW indexing, hybrid BM25 fusion, memory budgeting, and sharded vector databases.

    View skill
    $9$2.26Save 75%

    See it in action

    AI Agent Architect

    Example session with this skill installed

    Design the runtime decision loop for our refund agent (RefundOps).

    Support engineers spend 14 minutes per ticket manually checking dispute ledgers and fraud scores. We want RefundOps to autonomously process eligible low-risk refunds.

    • Subject: RefundOps v1.2 evaluating disputed merchant transactions.
    • Owner: Elena Rostova (VP Fintech Engineering). Decider: Risk Operations Guild.
    • Trigger: Webhook dispute_opened(case_id, tx_id, user_id, amount_usd).
    • Outcomes: refunded, escalated_risk, escalated_limit, rejected_ineligible, blocked_error.
    • Tools: ledger_read(tx_id), fraud_score_lookup(user_id), issue_refund(tx_id, amount, reason, idempotency_key), escalate_to_human(case_id, reason).
    • Envelope: Auto-refund <= $150/tx; daily customer cap $300; fraud score must be < 0.65.
    • Bounds: Max 8 turns, 24k context tokens, 45-second wall clock, $0.20 budget per run.
    • Tension: Support proposed prompt-only rules ('instruct LLM to respect $150 limit') and self-graded evaluation ('ask model if refund is compliant'). Risk insists tool proxy must hard-block > $150 and an independent ledger oracle must verify balance changes.

    Write the architecture under docs/architecture/agent-architect/.

    • Read your context and instructions
    • Compiled the ai agent architect
    • Generated the document

    Wrote docs/architecture/agent-architect/00-overview/agent-architect-overview.md. Complete agent runtime architecture specifying authority limits, step and tool budgets, human oversight gates, and anti-pattern verification.

    ---
    skill: agent-architect
    ---
    
    # AI Agent Architecture: RefundOps Agent [AA-REFUND-001]
    
    ## Summary
    
    This specification establishes the bounded autonomous runtime for RefundOps Agent, handling merchant disputes and consumer refund claims. The agent operates under hard programmatic authority limits: maximum $150 per automated transaction, daily user refund limit of $300, and mandatory human escalation for fraud risk scores >= 0.65 or claims above $150. It explicitly rules out autonomous policy overrides, self-adjudication, and direct ledger credit creation outside the guarded `issue_refund` tool interface.
    
    ## Detailed Description
    
    RefundOps processes refund requests received via inbound support cases. The agent analyzes transaction ledger data, queries the fraud score oracle, evaluates eligibility against refund policy rules, and either executes a bounded refund or delegates the case to human risk analysts.
    
    

    Incoming Case
    │
    ▼
    [ Runtime Envelope: 30 Tools / 120s ]
    │
    ├─► ledger_read ──► Verify Transaction
    ├─► fraud_score_lookup ──► Check Risk Metric
    │
    ├── Fraud Score >= 0.65 OR Amount > $150 ──► escalate_to_human
    └── Fraud Score < 0.65 AND Amount <= $150 ──► issue_refund

    
    ### Alternatives rejected
    
    | Option | Why it was not taken | Under what evidence it would win |
    |---|---|---|
    | Direct $300 Auto-Approval Ceiling | Fraud chargebacks increased by 18% in the preceding month; raising ceiling doubles exposed financial risk. | Reversal requires 60 consecutive days of fraud chargeback rates dropping below 1.0%. |
    | Prompt-Only Guardrails | LLM system instructions cannot guarantee financial ceilings; prompt injection could bypass threshold. | Rejected permanently; financial thresholds must be deterministically enforced by tool wrappers. |
    | Fully Manual Review | High ticket volume creates unacceptable resolution backlogs for trivial low-value claims. | Reversal if customer dispute volume drops below 50 tickets/day. |
    
    
    ## Contracts and Invariants
    
        Financial Authority Ceiling [INV-REFUND-01]
          The agent runtime wrapper strictly enforces that `issue_refund` cannot be invoked with `amount` > 150.00 USD, regardless of LLM reasoning or prompt injection. Violations immediately abort execution with error code ERR_AUTH_CEILING.
    
        Daily Aggregate Customer Limit [INV-REFUND-02]
          Total cumulative refunds issued to a single `user_id` within a rolling 24-hour window must not exceed 300.00 USD. If cumulative sum + requested amount > 300.00, execution delegates to `escalate_to_human`.
    
        Mandatory Escalation on Risk Score [INV-REFUND-03]
          Any case returning `fraud_score` >= 0.65 from `fraud_score_lookup` must trigger `escalate_to_human`. The agent is denied authority to call `issue_refund` when risk threshold is breached.
    
        Execution Resource Bounding [INV-REFUND-04]
          Runtime hard bounds: max 30 model tool iterations, 120 seconds wall-clock timeout. Upon exceeding either limit, the run aborts and falls back to a parked status in the human operator queue.
    
    ## Ownership and Handoffs
    
    | Concern | Owner | Handoff payload | Blocked until |
    |---|---|---|---|
    | Financial Authority & Limits | Risk Operations Guild (Elena Rostova) | Authority ceiling rules & escalation threshold definitions | Approved by Elena Rostova |
    | Tool Wrappers & Ledger Integration | Core Payments Engineering | OpenAPI schema for `ledger_read` and `issue_refund` | Wrapper integration test passes |
    | Human Review Console | Customer Support Operations | UI case queue format for `escalate_to_human` | Queue webhook receiver deployed |
    
    
    ## Traceability
    
    | Claim | Classification | Source | Freshness |
    |---|---|---|---|
    | Auto-approval max $150 | provided | Intake specification | Current |
    | Daily customer limit $300 | provided | Intake specification | Current |
    | 18% fraud chargeback increase | provided | Risk operations report | Stated in request |
    | Max 30 tool calls / 120s budget | provided | Intake specification | Current |
    | Deterministic wrapper enforcement | decided | Architectural decision AA-REFUND-001 | 2026-09-15 |
    
    
    ## Verification
    
    No validator was supplied, so no command was run.
    
    Reviewer self-check against fitness anti-patterns:
    - **Unbounded Autonomy Check**: PASS. Hard limits enforced: 30 tool calls, 120s timeout, $150 per transaction, $300 daily per user.
    - **Self-Graded Evaluation Check**: PASS. Agent does not grade its own decisions; risk scores originate from independent `fraud_score_lookup` oracle.
    - **Prompt-Only Control Check**: PASS. Ceilings enforced at tool boundary in backend wrapper code, not via LLM system prompt instructions.
    
    ## Open Decisions
    
    None. All constraints and boundaries derived directly from intake request.
    

    Next steps

    1. Review deterministic tool wrapper enforcement logic with Core Payments Engineering.
    2. Verify human review queue ingestion schema with Customer Support Operations lead.
    3. Establish weekly audit reconciliation between agent-issued refunds and ledger records.

    ai-agent-architect.pdf

    PDF · document

    Generated

    Example file from a real run - the skill writes it into your workspace.

    How to install

    Works the same in every agent - Claude, Cursor, Codex, Copilot and 20+ more.

    ~30 seconds
    1. 1

      Download the ZIP

      Free skills download straight away. Paid skills unlock right after purchase.

    2. 2

      Unzip into your skills folder

      Every agent reads skills from one folder on your machine. Drop the unzipped folder in there.

    3. 3

      Ask your agent to use it

      Restart the agent if it was already running. It picks the skill up automatically - no config needed.

    Skills folder by agent

    Click the path to copy it. Create the folder if it does not exist yet.

    Reviews

    No reviews yet

    Be one of the first to try it. Every skill in this bundle passes our trust checks.

    Security scanned

    Passed our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    30-day refund

    Not a fit? Get your money back

    Frequently asked questions

    More bundles from ledesixsixsix