Show HN: A CLI that writes its own integration code

We run superglue, an OSS agentic integration platform. Last week I talked to a founder of another YC startup. She found a use case for our CLI that we hadn't officially launched yet.

Her problem: customers wanted to create Opps in Salesforce from inside the chat in her app. We kept seeing this pattern: teams build agents and their users can perfectly describe what they want: "pull these three objects from Salesforce and push to nCino when X condition is true", but translating that into a generalized hard-coded tool the agent can call is a lot of work and does not scale since the logic is different for every user.

What superglue CLI does: you point it at any API, and your agent gets the ability to reason over that API at runtime. No pre-built tools. The agent reads the spec, plans the calls, executes them.

The founder using this in production described it like this: she gave the CLI to her agent with an instruction set and told it not to build tools, just run against the API. It handled multi-step Salesforce object creation correctly, including per-user field logic and record type templates.

Concretely: instead of writing a createSalesforceOpp tool that handles contact -> account -> Opp creation with all the conditional logic, you write a skill doc and let the agent figure out which endpoints to hit and in what order.

The tradeoff is: you're giving the agent more autonomy over what API calls it makes. That requires good instructions and some guardrails. But for long-tail, user-specific connectors, it's a lot more practical than building a tool for every case.

Happy to discuss. Curious if others have run into the "pre-defined tool" ceiling with MCP-based connectors and how you've worked around it.

Docs: https://docs.superglue.cloud/getting-started/cli-skills Repo: https://github.com/superglue-ai/superglue

docs.superglue.cloud

・

15 points

・

adinagoerres

・

3 days ago

12 comments

isabelleilyia ・ 3 days ago

After being a Superglue customer for 6 months now, I think their future is massive.

Building b2b saas nowadays requires products to be entirely open in terms of configuration and connection to people's greater systems, especially comparing with tools like Claude for specific verticals.

I had initially plugged in Superglue's CLI for the use case above - creating Salesforce opps. Since then, I've gotten the following behavior relatively out of the box (sometimes it just works live on call with a customer): 1. Searching Hubspot deals by some specific criteria 2. Copying and editing a slide deck

The development process with Superglue first went from hours building brittle code -> minutes building a tool. Now it's gone from that to simply an extra SKILL file as soon as we notice a trend in what customers are asking it to do.

Awesome team and awesome product. So lucky to be working with them :)

adinagoerres ・ 3 days ago

Adina here, one of superglue's creators. I'm curious to hear folks opinions on this. Also to clarify how agents are able to call APIs via superglue: the first step is to set up auth and systems on superglue so it can process and extract documentation and any other context for calling the APIs, which is then passed on to the agents

heushreck ・ 3 days ago

Feels like you’ve basically turned the “tooling bottleneck” into a prompt + policy problem, which is way more scalable but shifts the real challenge to constraint design and observability.

  • adinagoerres ・ 3 days ago

    Yes, we've seen this work best with clear instructions around Salesforce, Attio etc. superglue does come with a number of observability and monitoring features, but of course this can be extended for a specific setup.

jesseliii ・ 2 days ago

Would love to learn more about how the guardrails are set up - deterministically, or an llm evaluating them at runtime?

fiehtle ・ 3 days ago

integrations are the bottleneck, cli is the new ui