Superglue CLI: Let AI Agents Execute API Calls Without Pre-Built Tools

Superglue CLI is a command-line interface that ships with a structured skill reference teaching AI agents how to use every sg command, handle authentication, build tools, and debug failures. The core idea: instead of building hard-coded tools for every API integration, you point the agent at any API, and it can reason over that API at runtime by reading the spec, planning calls, and executing them.

Installation and Setup

Install the CLI globally via npm:

npm install -g @superglue/cli

Run interactive setup:

sg init

This prompts for your API key (available at app.superglue.cloud/admin), endpoint, and output preferences. For non-interactive environments like CI or AI agents, set environment variables:

export SUPERGLUE_API_KEY="your-api-key"
export SUPERGLUE_API_ENDPOINT="https://api.superglue.cloud"

Verify with sg system list — if you see auth errors, check your API key and endpoint.

Installing the Skill

The skill gives your AI agent full CLI knowledge — commands, auth patterns, tool schemas, debugging, and deployment. Install once and the agent references it automatically.

Universal install for all agents:

npx skills add superglue-ai/cli

Target specific agents with -g -a <agent>:

npx skills add superglue-ai/cli -g -a claude-code
npx skills add superglue-ai/cli -g -a codex
npx skills add superglue-ai/cli -g -a cursor

For Claude Code, install from the Anthropic marketplace:

/plugin install superglue@claude-plugins-official

Or load from local install:

claude --plugin-dir $(npm root -g)/@superglue/cli

For Cursor, copy the skill to your project or global directory:

cp -r $(npm root -g)/@superglue/cli/skills/superglue .cursor/skills/superglue
# Or globally
cp -r $(npm root -g)/@superglue/cli/skills/superglue ~/.cursor/skills/superglue

What the Skill Provides

• All CLI commands with flags, options, and usage patterns
• Authentication patterns — credential placeholders, OAuth flows, header formats
• Tool configuration schema — step configs, data selectors, transforms, pagination
• Debugging workflows — common errors, --include-step-results, sg system call for isolation
• Deployment patterns — SDK, REST API, webhooks (via references/integration.md)
• Specialized references for databases, file servers, and transforms (loaded on demand)

Adding Project-Specific Context

Add a section to your project's AI config file (CLAUDE.md, AGENTS.md, or .cursorrules) so the agent knows to use the skill and discover your setup dynamically. Include instructions like:

## Using Superglue
When working with superglue tools — via the CLI, SDK, or REST API:
1. Invoke the superglue skill and read the SKILL.md file before running any sg command
2. Read the relevant reference files for the task (integration, databases, file-servers, transforms)
3. Ensure the CLI is configured (sg init has been run or env vars are set)
4. Run sg system list and sg tool list to discover the current setup before building or modifying anything
5. Never hardcode system IDs or tool IDs — always discover them dynamically

Best Practices

Always test systems before building tools. Have the agent run sg system call to verify auth and see the actual response shape before constructing a tool config:

sg system call --system-id stripe \
  --url "https://api.stripe.com/v1/customers?limit=2" \
  --headers '{"Authorization":"Bearer <>"}'

Use --include-step-results when debugging to show the raw API response from each step — pinpoints whether the issue is auth, the endpoint, or a transform:

sg tool run --draft <id> --payload '{}' --include-step-results

Never paste secrets into chat. Use --sensitive-credentials when creating systems via the CLI so secrets are prompted securely.

This approach addresses the "pre-defined tool" ceiling where teams build agents but users describe specific needs like "pull these three objects from Salesforce and push to nCino when X condition is true." Instead of translating each request into a hard-coded tool, the agent can read the API spec and handle multi-step operations with per-user logic.