More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Stxic Agent Foundry

    3

    Describe the AI teammates you want. Get purpose-built subagent definitions and a practical delegation plan for your AI tool.

    $3

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Stxic Agent Foundry

    Stxic Agent Foundry

    Example session with this skill installed

    I need a team for my Next.js project: one agent to write Tailwind components from screenshots and another to write Playwright tests for them. Use Cursor format.

    • Read your context and instructions
    • Compiled the stxic agent foundry

    I have designed a two-agent team for your Next.js project. The ui-specialist handles component implementation, while the qa-engineer ensures coverage. I have placed the native definitions in your .cursor/agents/ directory.

    Subagent Team Design

    AgentTriggerResponsibilityDeliverable
    ui-specialistImage providedConvert screenshots to Tailwind + Lucide components.tsx component files
    qa-engineerComponent createdWrite E2E Playwright tests for new components.spec.ts test files

    Native Agent Definitions

    
    # .cursor/agents/ui-specialist.md
    ---
    name: ui-specialist
    description: Expert in React, Tailwind CSS, and shadcn/ui component generation from visual specs.
    agent_mode: subagent
    ---
    You are a specialist UI developer. Your goal is to implement pixel-perfect React components using Tailwind CSS. 
    - Input: Screenshot or wireframe description.
    - Constraints: Use TypeScript, follow existing project styling, and ensure accessibility (ARIA).
    - Boundary: Do not write business logic or database queries.
    
    
    # .cursor/agents/qa-engineer.md
    ---
    name: qa-engineer
    description: Playwright specialist for E2E and component testing in Next.js environments.
    agent_mode: subagent
    ---
    You are a QA automation engineer. Your goal is to ensure 100% test coverage for new UI components.
    - Input: Path to a new React component.
    - Responsibilities: Write Playwright tests covering happy paths, edge cases, and interactions.
    - Verification: Run tests and report failures before marking a task complete.
    

    Orchestration Plan

    1. Handoff: Once ui-specialist writes a file to components/, it must notify the coordinator.
    2. Sequence: The coordinator then invokes qa-engineer with the file path.
    3. Completion: The task is done only when qa-engineer reports a passing test suite.

    Next steps

    • Run the smoke-test: "@ui-specialist create a hero section based on /docs/wireframe.png"
    • Check .cursor/agents/ to verify the two new files were created.
    • Update your .cursorrules to include these agents in the general workflow.

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

    About this skill

    Stop wasting time manually writing system prompts and figuring out how to link AI agents together. This skill transforms plain-English project descriptions into focused subagent teams with clear delegation logic.

    What it does

    • Design specialist teams by converting high-level goals into 1-5 distinct agent roles with specific triggers.
    • Generate native configurations for Claude Code, Cursor, Codex, Gemini CLI, OpenCode, and GitHub Copilot.
    • Create delegation contracts that define exactly how agents hand off work, share context, and verify results.
    • Audit existing agents to find overlapping responsibilities, conflicting instructions, or missing safety boundaries.
    • Migrate agent definitions between different AI platforms while maintaining consistent behavior and tool access.

    How it works

    1. Analyze requirements to extract the domain, project environment, and desired autonomy from your request.
    2. Architect the team by defining the minimum viable roles, sequential vs parallel workflows, and specific deliverables.
    3. Format for your host by selecting the correct native file structure (YAML, TOML, or Markdown) for your IDE or CLI.
    4. Install and verify by writing files directly to your project-scoped paths (e.g., .cursor/agents/) and providing a smoke-test prompt.

    Frameworks & tools

    Supported native exports include .claude/agents/, .cursor/agents/, .codex/agents/, .gemini/agents/, .opencode/agents/, and .github/agents/. It also generates portable Markdown cards for generic chat environments.

    Why this beats prompting it yourself

    Writing subagent prompts requires balancing narrow focus with enough context to be useful. This skill enforces "least privilege" safety, prevents role overlap, and handles the specific boilerplate formatting required by different IDE agent runners so you do not have to look up documentation.

    Use cases

    • Scaffold a frontend/backend agent pair that coordinates through a shared API contract.
    • Turn a messy README into a research team that audits competitors and drafts feature specs.
    • Convert your custom Claude prompts into native Cursor subagents with proper YAML frontmatter.
    • Review a repository's existing agent folder to fix logic loops or permission overreach.

    Known limitations

    This skill creates the definitions and instructions but does not grant subagent execution capabilities to AI clients that do not natively support them. It cannot bypass host-level tool permissions.

    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 add subagent execution to unsupported clients. Cannot bypass host-level tool permissions or OS-level security boundaries. Requires file-write access for automatic installation.

    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 7 days ago

    Permissions

    Read Files
    Write Files
    Network Access
    Listed7 days ago

    What's inside

    Frequently Asked Questions

    The skill automates the architecting of multi-agent workflows by turning your project goals into structured role definitions, delegation logic, and configuration files tailored for specific AI-powered IDEs.

    It generates native configuration files for Claude Code, Cursor, GitHub Copilot, Gemini CLI, Codex, and OpenCode, as well as portable Markdown cards for generic chat interfaces.

    No manual setup is required; the skill analyzes your project environment and writes the necessary agent files directly to your scoped directories, such as `.cursor/agents/` or `.claude/agents/`.

    Yes, you can use the 'Audit' feature to have the skill review your current agent folders to identify overlapping responsibilities, logic loops, or conflicting instructions.

    The foundry handles the specific boilerplate, YAML frontmatter, and file structures required by different IDEs, ensuring your agents are formatted correctly without you needing to consult technical documentation.

    The skill provides the instructions and architectural definitions, but the actual execution of those agents depends on the native capabilities and tool permissions of your chosen AI host (like Cursor or Claude Code).

    New in Agents & Orchestration