Superglue CLI + Skills - Set Up AI Agents via the CLI

TL;DR

TL;DR: Superglue is an open-source CLI and skill framework that lets AI agents build, manage, and orchestrate their own integration tools at runtime — no manual wiring required.

Source and Accuracy Notes

• Official docs: https://docs.superglue.cloud/
• Getting started: https://docs.superglue.cloud/getting-started/cli-skills
• GitHub: https://github.com/superglue (assumed)

What Is Superglue?

Superglue is an AI-native integration layer that flips the traditional ETL/bot paradigm. Instead of you wiring integrations by hand, you describe what you want in plain language and the AI agent builds the integration code itself. The CLI is the primary interface; the “skill” concept lets agents extend themselves with new capabilities at runtime.

Key concepts:

• CLI-first — all operations happen through a terminal command set
• Self-writing integrations — agents generate integration code rather than calling pre-built connectors
• Skill system — extensible capability modules agents can add to themselves
• Multi-agent aware — designed for workflows where multiple agents coordinate

Setup Workflow

Step 1: Install the CLI

npm install -g @superglue/cli
# or
brew install superglue

Step 2: Authenticate

superglue auth login

Step 3: Initialize a Project

superglue init my-project
cd my-project

Step 4: List Available Skills

superglue skills list

Step 5: Add a Skill to Your Agent

superglue skills add github-integration

Step 6: Run a Skill-Based Task

superglue run "check github issues for repo owner/repo"

Deeper Analysis

How the CLI Generates Code

When you issue a task, the CLI sends the goal to your configured LLM (supports OpenAI, Anthropic, or local models). The model decides which skill to invoke and generates the necessary glue code on the fly. This is the core “self-writing” promise — the agent is not calling a fixed connector, it is constructing the connection logic dynamically.

Skill Architecture

Skills are modular packages that define:

• Triggers — what events or commands activate the skill
• Actions — the operations the skill can perform
• Schema — the interface contract other skills or agents can rely on

You can write custom skills in TypeScript or Python and publish them to the skill registry.

Comparison with Alternatives

| Feature | Superglue | Zapier | n8n | |---|---|---|---| | AI writes integrations | Yes | No | No | | CLI-first | Yes | No | Yes | | Self-hostable | Yes | No | Yes | | Skill extensibility | Yes | Limited | Moderate | | Open source | Yes | No | Yes |

Practical Evaluation Checklist

• [ ] CLI installs without dependency conflicts
• [ ] superglue auth login completes successfully
• [ ] superglue skills list returns at least 3 skills
• [ ] A simple task runs without errors
• [ ] Custom skill can be added and invoked
• [ ] Output is reproducible across runs

Security Notes

• API keys are stored in the local credentials store, not in project files
• Generated code is sandboxed per execution run
• Network calls go through a configurable proxy
• Skills are version-pinned; audit before adding unknown skills

FAQ

Q: Does Superglue require an API key for every integration? A: Yes, each skill needs its own credentials. Superglue stores them securely in a local vault rather than plaintext config.

Q: Can I self-host Superglue? A: Yes, the core CLI and skill runner are open source and can be self-hosted. The skill registry has a hosted option.

Q: What LLMs does it support? A: OpenAI GPT-4o, Anthropic Claude 3.5/3.7, and any OpenAI-compatible local model.

Q: How is this different from LangChain tools? A: LangChain tools are pre-built callables. Superglue generates the tool code at runtime based on your goal — no tool definition required upfront.

Conclusion

Superglue is a practical CLI-first integration layer where AI agents construct their own glue code rather than calling fixed connectors. If you want agents that adapt and extend their integration capabilities on the fly — without you pre-wiring every connection — it is worth a spin. Start with npm install -g @superglue/cli, run superglue init, and try a skill-based task to see if the self-writing model fits your workflow.