Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Agent Tool Integration Developer Skill

    1

    Design and implement secure, resilient API tool contracts and execution logic for AI agents.

    $39.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Agent Tool Integration Developer Skill

    Agent Tool Integration Developer Skill

    Example session with this skill installed

    Create a tool contract and implementation plan for a GitHub 'create-issue' tool using Node.js and Octokit. Must handle rate limits and require a confirmation step for the write action.

    • Read your context and instructions
    • Compiled the agent tool integration

    I have designed the integration for the GitHub issue creation tool. This plan includes a typed schema, idempotency logic, and a two-stage authorization flow for write operations.

    GitHub Create Issue Tool Integration

    1. Tool Contract (JSON Schema)

    {
  "name": "github_create_issue",
  "description": "Creates a new issue in a specified GitHub repository. Use only when a user explicitly requests to report a bug or suggest a feature.",
  "parameters": {
    "type": "object",
    "properties": {
      "owner": { "type": "string", "description": "The account owner of the repository." },
      "repo": { "type": "string", "description": "The name of the repository." },
      "title": { "type": "string", "minLength": 1, "maxLength": 256 },
      "body": { "type": "string", "description": "Markdown content for the issue description." },
      "labels": { "type": "array", "items": { "type": "string" } }
    },
    "required": ["owner", "repo", "title"]
  }
}

    2. Implementation Logic (Node.js/Octokit)

    import { Octokit } from "@octokit/rest";

async function createGitHubIssue(args) {
  const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });
  
  try {
    const response = await octokit.rest.issues.create({
      owner: args.owner,
      repo: args.repo,
      title: args.title,
      body: args.body,
      labels: args.labels
    });
    
    return { ok: true, data: { id: response.data.id, url: response.html_url } };
  } catch (error) {
    return normalizeError(error);
  }
}

function normalizeError(err) {
  const isRateLimit = err.status === 403 && err.headers['x-ratelimit-remaining'] === '0';
  return {
    ok: false,
    error: {
      code: isRateLimit ? "RATE_LIMITED" : "PROVIDER_ERROR",
      retryable: isRateLimit || err.status >= 500,
      message: err.message
    }
  };
}

    Next steps

    • Set the GITHUB_TOKEN environment variable with repo scope.
    • Implement a UI-level confirmation dialog for the github_create_issue tool call.
    • Configure the agent to respect the retryable: true flag in the error response.

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

    About this skill

    Building integrations that allow AI agents to interact with the real world is error-prone. This skill standardizes how agents call external APIs and custom functions, ensuring every tool interaction is secure, resilient, and typed. ## What it does - **Tool contract design**: generates strict JSON Schema or typed definitions for agent functions, including enums and constraints to prevent model hallucination. - **Authentication architecture**: designs secure flows for OAuth 2.0, API keys, and bearer tokens using environment-based secret management and least-privilege principles. - **Resilience engineering**: implements bounded exponential backoff, jitter, and idempotency logic to handle transient network failures and rate limits. - **Error normalization**: transforms complex provider-specific API errors into machine-readable internal formats for better agent reasoning. - **Security enforcement**: applies SSRF protection, host allowlisting, and output sanitization to prevent untrusted API data from compromising the agent. ## How it works 1. **Map the operation**: define the user intent, side effects, and success criteria for the specific tool or API endpoint. 2. **Define the schema**: build a typed contract with explicit input validation, required fields, and compact output shapes. 3. **Implement the adapter**: write the transport logic, including timeout settings, authentication headers, and response parsing. 4. **Configure resilience**: set retry policies based on the operation's idempotency and the provider's rate-limiting headers. ## Frameworks & tools Works with any language or framework used for agentic workflows, including Python, Node.js, LangChain, and AutoGen. It supports REST, GraphQL, and custom internal RPC services. ## Why this beats prompting it yourself Generic prompts often produce tools with weak validation, hard-coded secrets, or no retry logic, causing agent crashes during production spikes. This skill enforces a professional integration workflow that handles edge cases like 429s and partial failures that simple prompts ignore. ## Use cases - **External API integration**: building a secure Slack, GitHub, or Stripe tool for a customer service agent. - **Database bridges**: creating read/write tools for internal SQL or NoSQL databases with strict authorization controls. - **Workflow coordination**: designing tools that trigger multi-step background jobs or long-running processes. - **Legacy system access**: wrapping internal SOAP or custom RPC services in agent-friendly JSON contracts. ## Known limitations This skill focuses on the integration layer and tool contracts. It does not author Model Context Protocol (MCP) servers or manage high-level multi-agent orchestration logic.

    Focuses on the integration layer and tool contracts. Does not author MCP servers or manage high-level agent orchestration.

    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

    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

    Network Access
    Listed7 days ago

    What's inside

    Frequently Asked Questions

    This skill provides a standardized framework for designing secure API contracts and execution logic, preventing common issues like model hallucinations, unhandled rate limits, and security vulnerabilities like SSRF.

    Yes, the skill is framework-agnostic and generates standardized schemas and adapter logic compatible with Python, Node.js, LangChain, AutoGen, and most custom agentic workflows.

    The skill enforces least-privilege principles by implementing secure OAuth 2.0 flows and environment-based secret management, ensuring your agent never exposes API keys or sensitive credentials.

    It implements resilience patterns like bounded exponential backoff and idempotency logic, allowing your agent to gracefully handle 429 rate limits and transient network failures instead of crashing.

    You receive a comprehensive integration kit including tool contract templates, security enforcement protocols, and standardized adapter logic for connecting agents to external services.

    New in APIs & Backend