More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Astra orchestrator

    1

    Coordinate multi-agent coding tasks with structured delegation, automated verification, and independent Astra reviews.

    Free

    1 useSecurity scanned
    Astra orchestrator

    Astra orchestrator

    Example session with this skill installed

    I need to implement a new Auth middleware in /src/middleware and update the User routes in /src/routes. Use Astra to plan and review, and Luna for the implementation.

    • Read your context and instructions
    • Compiled the astra orchestrator

    I have initialized the orchestration plan for the Auth middleware and User routes. I will delegate the implementation to a Luna worker and then initiate an independent Astra review.

    **Route:** 1 Implementer (`astra_luna_worker`) -> 1 Reviewer (`astra_review`)
    **Owned Paths:** `/src/middleware/auth.ts`, `/src/routes/user.ts`
    

    Execution Record

    StageAgent IDRoleResult
    PlanningPrimaryOrchestratorRoute: Standard Implementation
    Implementationworker-9921astra_luna_workerCreated auth.ts, updated user.ts
    VerificationPrimaryIntegrity CheckDiffs verified; exports match spec
    Reviewrev-4402astra_reviewAccepted

    Implementation Details

    The Luna worker successfully implemented the JWT validation logic in auth.ts and attached the middleware to the /profile and /settings endpoints in user.ts. I verified that no other files in /src/routes were modified.

    Next steps

    • Run the local test suite npm test to verify the middleware integration.
    • Check the auth.ts file to ensure the environment variables for secrets match your .env.
    • Deploy to the staging environment for integration testing.

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

    About this skill

    Managing complex code changes requires precise coordination to avoid overlapping edits and wasted compute. The Astra Orchestrator skill manages implementation tasks by delegating work to native subagents with strict contracts and independent verification. It eliminates the friction of manual multi-file coordination by planning the route, spawning specialized workers, and conducting a final review before merging.

    What it does

    • Route selection determines the most efficient path between primary agents, implementers, and reviewers based on task size.
    • Contract delegation provides subagents with exact file ownership, behavior requirements, and boundary constraints to prevent scope creep.
    • Native subagent spawning utilizes host tools to launch specialized profiles for implementation (Luna) and independent review (Astra).
    • Automated verification runs acceptance checks on diffs and generated files before proceeding to formal review.
    • Independent review cycles trigger a fresh Astra reviewer to validate changes against the original goal without allowing self-repair.

    How it works

    1. Plan the implementation by inspecting the working tree and selecting the appropriate worker route.
    2. Delegate specific behaviors and file paths to a Luna subagent using native spawn tools.
    3. Verify the output by inspecting diffs and running defined checks, requesting repairs if necessary.
    4. Review the final result using an independent Astra reviewer to get a final accept or fix verdict.

    Frameworks & tools

    This skill is designed for environments supporting native subagent tools (spawn, message, wait) and specific worker profiles like astra_luna_worker and astra_review. It integrates directly with host permissions and file systems.

    Why this beats prompting it yourself

    Manual orchestration often leads to agents overwriting each other's work or losing context during delegation. This skill enforces strict file ownership and independent review stages, ensuring that code is not just written, but verified by a separate model instance before you ever see it.

    Use cases

    • Multi-file features where one agent implements logic while another handles documentation or integration.
    • Critical path updates that require an independent Astra review for high-assurance code quality.
    • Codebase refactoring where specific subagents are assigned bounded directories to prevent global side effects.
    • Parallel development of independent modules that need central coordination and verification.

    Known limitations

    Requires a host with native subagent tool support. Cannot switch the primary model of an existing conversation or access token usage data without specific host tool support.

    Requires host support for native spawn/message tools. Cannot force model switches in existing sessions. Token reporting is dependent on host-provided metadata.

    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

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    macOS
    Node.js
    Git

    Permissions

    Read Files
    Write Files
    Network Access
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    Astra Orchestrator eliminates 'scope creep' and conflicting edits by assigning subagents strict file ownership and boundary constraints, ensuring they only modify specific directories without overlapping.

    This skill requires a host environment that supports native subagent tools like 'spawn' and 'message,' and is optimized for the Astra Luna and Astra Review specialized profiles.

    Unlike manual prompting, the Orchestrator enforces an independent review cycle where a fresh Astra instance validates code, preventing the implementation agent from 'grading its own homework.'

    The skill includes the primary orchestration logic, pre-defined route selection workflows for task scaling, and the verification protocols for Luna and Astra subagent interactions.

    While highly effective for multi-file refactoring, the skill requires host-level permissions for subagent spawning and cannot access real-time token usage data unless the host provides a specific tool for it.

    New in Agents & Orchestration