Skip to content

jeremylongshore/tons-of-skills-marketplace / plugins/ai-ml/ai-sdk-agents/skills/orchestrating-multi-agent-systems

orchestrating-multi-agent-systems

Verified

Execute orchestrate multi-agent systems with handoffs, routing, and workflows across AI providers. Use when building complex AI systems requiring agent collaboration, task delegation, or workflow coordination. Trigger with phrases like "create multi-agent system", "orchestrate agents", or "coordinate agent workflows".

FileKindSize
SKILL.mdskill md5.4 KB
assets/README.mdmarkdown333 B
assets/agent_template.tsscript3.8 KB
assets/example_coordinator.tsscript3.7 KB
assets/example_workflow.jsonconfig6.7 KB
references/README.mdmarkdown56 B
references/errors.mdmarkdown1.1 KB
references/examples.mdmarkdown12.6 KB
references/implementation.mdmarkdown1.5 KB
scripts/README.mdmarkdown380 B
scripts/agent_setup.pyexecutablescript2.5 KB
scripts/dependency_installer.pyexecutablescript2.7 KB
scripts/env_setup.pyexecutablescript2.5 KB

assets/agent_template.ts

View on GitHub
/**
 * Agent Template
 *
 * This file provides a template for creating new agents within the ai-sdk-agents plugin.
 * Use this as a starting point to define the behavior and capabilities of your agent.
 *
 * Instructions:
 * 1.  Replace the placeholder values with your agent's specific details.
 * 2.  Implement the `execute` method to define the agent's core logic.
 * 3.  Define the agent's tools and capabilities using the `AgentCapabilities` interface.
 * 4.  Ensure your agent properly handles errors and exceptions.
 * 5.  Consider adding logging and monitoring for improved observability.
 */

import { Agent, AgentCapabilities, AgentContext } from '@ai-sdk/core'; // Replace with actual import path if needed

// Define the specific capabilities of this agent.  Adjust as needed.
interface MyAgentCapabilities extends AgentCapabilities {
    [key: string]: any; // Allows for flexible capability definitions.  Consider more specific types.
    // Example:
    // summarizeText: (text: string) => Promise<string>;
    // translateText: (text: string, targetLanguage: string) => Promise<string>;
}

/**
 * MyAgent Class
 *
 *  A template for creating new AI agents.
 */
export class MyAgent implements Agent<MyAgentCapabilities> {
    // Agent Name (Required)
    name: string = "MyAgentName";

    // Agent Description (Required)
    description: string = "A brief description of what this agent does.";

    // (Optional) Specific instructions or persona for the agent
    instructions?: string = "You are a helpful assistant...";


    /**
     * Constructor
     *
     * @param capabilities - The capabilities of the agent (tools, functions, etc.).
     */
    constructor(public capabilities: MyAgentCapabilities) {
        // Initialization logic can go here.
    }


    /**
     * Execute Method
     *
     * This is the core logic of the agent.  It receives the user's input and the agent's context.
     *
     * @param input - The user's input.
     * @param context - The agent's context (access to other agents, data, etc.).
     * @returns A promise that resolves to the agent's response.
     */
    async execute(input: string, context: AgentContext): Promise<string> {
        try {
            // Implement your agent's logic here.
            // Example:
            // const summary = await this.capabilities.summarizeText(input);
            // return summary;

            // Placeholder response:
            return `Agent ${this.name} received input: ${input}.  This is a placeholder response.`;

        } catch (error: any) {
            console.error(`Error in agent ${this.name}:`, error);
            return `Agent ${this.name} encountered an error: ${error.message || error}`;
        }
    }
}


/**
 * Example Usage (for testing/demonstration purposes)
 */
async function main() {
    // Example capabilities (replace with actual implementations)
    const myCapabilities: MyAgentCapabilities = {
        // Example:
        // summarizeText: async (text: string) => `Summarized: ${text.substring(0, 50)}...`,
        // translateText: async (text: string, targetLanguage: string) => `Translated to ${targetLanguage}: ${text}`,
    };

    const myAgent = new MyAgent(myCapabilities);

    const context: AgentContext = {
        getAgent: async (name: string) => {
            console.warn(`Attempted to get agent ${name}, but no other agents are defined in this example.`);
            return undefined;
        },
        getPluginData: async (key: string) => {
            console.warn(`Attempted to get plugin data for key ${key}, but no plugin data is defined in this example.`);
            return undefined;
        },

    };

    const userInput = "This is a test input for the agent.";
    const response = await myAgent.execute(userInput, context);

    console.log("Agent Response:", response);
}

// Run the example (optional - remove in production)
// main();
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 323kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 323kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 323kUpdated Claude CodeCodexVerifiedInstall