More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    forgeagent architect

    1

    Architect and security-audit production-grade Claude agents and MCP servers with enterprise guardrails.

    Free

    5 uses3.0 (1 review)
    forgeagent architect

    forgeagent architect

    Example session with this skill installed

    Architect an autonomous agent that monitors Stripe dispute webhooks, queries PostgreSQL billing logs read-only, and posts a Slack alert to #billing-alerts when a dispute amount exceeds $500. It must never issue refunds automatically. Use the cheapest viable Claude model.

    • Read your context and instructions
    • Compiled the forgeagent architect

    Summary

    Designed a production-grade

    Stripe Dispute & Reliability Guard agent topology with least-privilege tool grants, PostgreSQL RLS tenant isolation, and strict human review gates. Verified compliant with the

    Agensi.io 8-Point Security Framework (100/100 score).

    Metric / CheckSettingSafety Standard
    Target Modelclaude-3-5-sonnet-latestHigh-reasoning log parsing ($3.00/1M input)
    Daily Budget Cap$6.00 / dayHard ceiling to prevent runaway API spend
    Autonomy Levelact_after_approvalRequires explicit confirmation for actions
    Database SecurityPostgreSQL RLSStrict tenant isolation via asAgent() session
    Network PerimeterSSRF BlockedDenies RFC1918 private IPs & cloud metadata
    Secret HandlingAES-256-GCM / scryptZero plain-text credentials in prompts
    Agensi Security Audit8/8 PASSEDCWE-862, CWE-918, CWE-200, CWE-77 clean

    1. Generated ForgeAgent v1.2 JSON Specification

    {
      "version": "1.2.0",
      "name": "StripeDisputeReliabilityGuard",
      "role": "Financial Dispute Monitoring & Verification Engineer",
      "mission": "Monitor Stripe webhook dispute events, cross-reference PostgreSQL billing logs, and post internal Slack alerts when dispute amount exceeds $500. Strictly forbidden from issuing refunds or modifying subscriptions without human sign-off.",
      "type": "monitoring",
      "subcategory": "Billing Reliability",
      "model": "claude-3-5-sonnet-latest",
      "autonomy": "act_after_approval",
      "allowedActions": [
        "Query Stripe dispute events",
        "Read PostgreSQL billing logs",
        "Post internal Slack notification"
      ],
      "forbiddenActions": [
        "Issue automated refunds",
        "Modify customer subscriptions",
        "Delete billing records",
        "Expose API keys or private tokens"
      ],
      "tools": [
        {
          "connectorId": "mcp_postgres_read",
          "access": "read",
          "description": "Read-only access to customer transaction ledgers",
          "annotations": {
            "readOnlyHint": true,
            "destructiveHint": false,
            "idempotentHint": true,
            "openWorldHint": false
          }
        },
        {
          "connectorId": "mcp_slack_notify",
          "access": "read_write",
          "description": "Post alerts to internal #billing-alerts channel",
          "annotations": {
            "readOnlyHint": false,
            "destructiveHint": false,
            "idempotentHint": false,
            "openWorldHint": true
          }
        }
      ],
      "triggers": ["webhook", "message"],
      "costCapPerDay": 6.00,
      "securityPolicy": {
        "rlsIsolation": true,
        "ssrfProtection": true,
        "secretsHandling": "scrypt_aes_gcm_isolated",
        "promptInjectionDefense": true
      }
    }
    

    2. Production TypeScript / Zod Input Guardrail

    import { z } from 'zod';
    
    // SSRF-safe URL validator
    const SafeUrl = z.string().url().refine((val) => {
      const host = new URL(val).hostname.toLowerCase();
      return !/^(localhost|127\.|10\.|172\.(1[6-9]|2[0-9]|3[01])\.|192\.168\.|169\.254\.)/.test(host);
    }, { message: 'SSRF blocked: URL must resolve to a public host' });
    
    export const DisputeInputSchema = z.object({
      disputeId: z.string().regex(/^dp_[a-zA-Z0-9]+$/, 'Invalid dispute ID format'),
      amountCents: z.number().int().positive().max(1_000_000),
      currency: z.enum(['usd', 'eur', 'gbp']),
      reason: z.string().trim().min(3).max(500)
    }).strict();
    
    export type DisputeInput = z.infer<typeof DisputeInputSchema>;
    

    Next steps

    • Import the generated spec.json into your local agent harness.
    • Install zod (npm install zod) and use DisputeInputSchema to validate agent tool calls.
    • Pair with forgeagent-evaluator to run automated 4-tier regression tests before shipping.

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

    About this skill

    Hardening autonomous agents for production requires more than a simple system prompt. Most agents lack proper security boundaries, leading to SSRF vulnerabilities, data leaks, or runaway costs. This skill enforces the internal architecture standards of ForgeAgent, ensuring every agent you build is secure, multi-tenant aware, and cost-optimized.

    What it does

    • Agent Topology Design constructs the full architecture from natural language briefs including model selection and role boundaries.
    • Security Auditing stress-tests designs against the Agensi 8-Point framework covering RLS, SSRF, and injection vectors.
    • Spec Generation produces validated ForgeAgent v1.2 JSON specifications ready for production deployment.
    • Validation Scaffolding creates TypeScript and Zod modules to enforce runtime payload integrity and network safety.
    • Human-in-the-Loop Gating identifies destructive actions and injects mandatory confirmation triggers.

    How it works

    1. Scope Triangulation defines the identity, mission, and hard operational stops for the agent.
    2. Model Tiering selects the optimal Claude model (Haiku, Sonnet, or Opus) based on task complexity and token budget.
    3. Security Hardening configures Row Level Security (RLS) and SSRF network perimeters.
    4. Artifact Delivery outputs a validated spec.json and a production-ready TypeScript validation module.

    Frameworks & tools

    Built for Claude (3.5/3.7/Opus) and the Model Context Protocol (MCP). It generates code compatible with TypeScript, Zod, and PostgreSQL RLS.

    Why this beats prompting it yourself

    Generic prompts often ignore the "boring" security details like SSRF host verification or MCP idempotency hints. This skill automates enterprise-grade guardrails that are difficult to maintain manually across multiple agents.

    Use cases

    • Designing a billing agent that queries PostgreSQL transaction logs while blocked from issuing refunds.
    • Building a customer support agent with strict SSRF protection to prevent access to cloud metadata.
    • Creating a multi-tenant monitoring agent that uses RLS to isolate sensitive user data.

    Known limitations

    Requires Zod for runtime schema validation. Does not provide the actual execution runtime, only the architectural specifications and validation logic.

    Requires Zod for runtime validation. Does not provide an execution runtime. Designed specifically for Claude-based MCP architectures.

    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 any payment.

    Reviews

    3.0
    1 review
    5
    0
    4
    0
    3
    1
    2
    0
    1
    0

    This skill has been used 5 times.

    Trust & safety

    Security scan

    Security scan passed 4 days ago

    • Free with an Agensi account

    Requires

    Node.js 18+
    zod
    Node.js

    Permissions

    Read Files
    Write Files
    Terminal / Shell

    File Scopes

    **/*.json
    **/*.ts
    references/spec-schema.json

    Reads local workspace files (package.json, schema files, .env.example) to detect existing MCP servers, database types, and auth models, guaranteeing generated agent specs align with your existing stack. Generates local spec.json and Zod schema files. No remote data exfiltration or external credentials required.

    Listed7 days ago
    Updated4 days ago

    What's inside

    Frequently Asked Questions

    This skill automates the design of production-ready Claude agents by generating validated specifications and security guardrails that prevent vulnerabilities like SSRF and unauthorized data access. It moves beyond simple prompting to provide a full architectural blueprint, including Zod schemas and TypeScript validation modules.

    The skill is specifically optimized for Claude models (3.5, 3.7, and Opus) and is built to generate code compatible with the Model Context Protocol (MCP), TypeScript, and PostgreSQL. It requires the Zod library for its runtime schema validation logic to function as intended.

    Every purchase includes the forgeagent architect skill, validated ForgeAgent v1.2 JSON specification templates, and production-ready TypeScript scaffolding for enforcing payload integrity and network safety. It does not include an execution runtime or hosting environment.

    While it doesn't provide a live sandbox, it includes a 'Security Auditing' feature that stress-tests your architectural designs against the Agensi 8-Point framework. This proactively identifies risks like injection vectors and missing Row Level Security (RLS) before you deploy to production.

    Yes, the skill includes a 'Model Tiering' logic that helps you select the most cost-efficient Claude model (Haiku, Sonnet, or Opus) based on your specific task complexity and token budget requirements.

    New in Prompt & Skill Engineering