Introducing the AI Tool Builder: Connect Any API to Your Agents by Chatting

That's the gap the AI Tool Builder closes. Shipped on March 30, it lets you connect any REST API to your agents from a conversation: describe the API in plain language, paste your credentials, and Macha discovers the endpoints, tests them against the live service, and turns the working ones into agent tools — grouped, authenticated, and ready to assign. No OpenAPI spec to upload, no glue code, no Postman collection. You talk; it wires.

This post walks through what actually shipped, how the builder works step by step, the manual path for when you want precise control, and an honest read on where it fits — and where it doesn't.

Why "connect any API" is the hard part of agents

Most "build an AI agent" tutorials stop at the model and the prompt. The unglamorous truth is that the integration layer is where agent projects stall. To make a single REST endpoint usable by an agent you normally have to: read the vendor's API docs, model the request (path, query params, body), wire up authentication, handle the response shape, and then describe the whole thing to the model so it knows when to call it and what arguments to pass.

The industry has converged on a few ways to ease this. The Model Context Protocol (MCP) standardises how tools are exposed to models; automation platforms like n8n let you expose existing nodes as agent tools; and OpenAI, Google's Vertex AI, and Zendesk all ship "integration builders" of one kind or another. They work — but most still assume you'll hand-map endpoints or stand up a server. Macha's bet is simpler: the fastest spec for an internal API is a sentence describing it plus a working credential, and an AI that's allowed to try the call and learn from the response.

Tool Builder vs MCP server vs unified API vs direct API calls

Before you reach for the Tool Builder, it's worth knowing where it sits among the other ways to give an agent an external capability. There are four common patterns, and they don't compete so much as fit different jobs. The table below is the quick read; the short version is that the Tool Builder owns the long tail — the internal and niche REST APIs nobody ships a packaged connector for — while MCP servers and unified APIs earn their keep when the same integration has to be reused at scale.

A useful rule of thumb the broader ecosystem has settled on: direct API calls win when you need exact, repeatable, low-latency behaviour; MCP shines when one capability is reused across many agents and you're abstracting complexity for better reasoning; and unified-API platforms reduce integration surface area when you're connecting many apps in the same category. The Tool Builder isn't trying to replace any of those — it's the fastest path for the one internal service that none of them will ever package for you. (And because an auto-built tool can later be promoted to a maintained connector or MCP server, starting in the Tool Builder doesn't lock you out of those paths.)

How the AI Tool Builder works

You start the builder from the Custom Tools area, which gives you two ways in: Build with AI (the conversational path) and Create Custom Tool (the manual editor).

Pick Build with AI and describe what you want to connect — for example, "Connect our ShipStation account so agents can look up shipment tracking by order number." From there the AI drives four things, in order.

1. It discovers and tests endpoints. You describe the API and paste your credentials. Macha proposes the endpoints that match your intent and then actually calls them against the live service. Tools are created from the requests that succeed — so a tool exists in your library only after it has demonstrably returned a real response, not because a doc said it should.

2. Smart auth handling. Credentials are captured from the first successful test request and applied to every tool created in that session. You authenticate once in the conversation; the builder doesn't make you re-paste the same bearer token for each endpoint it discovers. Macha supports the auth schemes real REST APIs use — API key, bearer token, and basic auth.

3. Auto-grouping into a connector. The tools the builder creates are automatically grouped under a single named connector, complete with an emoji icon and a brand colour, and that group shows up on your connectors page alongside the native integrations. So a one-off internal API ends up looking and behaving like a first-class connector, not a loose pile of HTTP calls.

4. Auto-detected write protection. This is the safety beat that matters. The builder inspects the HTTP method: anything that mutates state — POST, PUT, PATCH, DELETE — is automatically flagged as a write operation that requires confirmation. Read-only GET tools can run freely; a tool that cancels an order or issues a refund won't fire without an explicit go-ahead. You don't have to remember to set this; it's inferred from the method and on by default.

The result of a five-minute conversation is a working connector your agents can use immediately.

The manual path: Custom API Tools

The AI Tool Builder is the fast lane, but it sits on top of a full manual tool editor — and sometimes you want the manual editor. If your endpoint needs a hand-tuned request body, a specific header, or query parameters the AI couldn't infer from your description, you build the tool by hand.

A custom tool is just a defined HTTP request: choose the method, set the URL with parameters, supply a body template for writes, and pick the authentication. Credentials are encrypted at rest, and (from the same March 30 release) the edit modal shows a masked hint of the configured key so you can confirm which key is wired up without ever exposing the secret.

The most important habit here is the built-in test. You can fire the endpoint directly from the tool editor — before it ever touches an agent — and confirm it returns what you expect.

A few quality-of-life fixes landed alongside the builder that you feel most when editing by hand: you can delete a tool inline from the list without opening the modal, and empty optional parameters are automatically stripped from the request URL — which quietly fixes a whole class of failures from APIs that reject empty query values.

From tool to working agent

Building the tool is half the job; the agent has to actually use it. Created tools live in your library and on the connectors page, and you assign them to an agent the same way you assign native ones — from the agent's tool picker.

Because the auto-grouped connector behaves like any other, your custom API shows up right next to Zendesk and Shopify when you're composing an agent.

A practical pattern: a triage agent reads a new Zendesk ticket (native connector), calls your custom carrier tool to fetch live tracking (built in five minutes with the Tool Builder), and drafts a reply with the real ETA — pausing for confirmation only if the customer asked to change the address, because that's a PUT the builder flagged as a write. Every tool call the agent makes draws on your credit balance the same way any other AI action does (credits are per action, with the model you choose determining the rate — default GPT-5.4 Mini = 1 credit), so the economics are identical to your native-connector workflows.

Watch-outs: when not to reach for it

The Tool Builder is genuinely fast, but it isn't magic, and a few honest caveats keep you out of trouble:

• It needs working credentials and a reachable endpoint. The builder learns by making real calls. If the API is behind a VPN, IP allowlist, or an OAuth dance Macha can't complete with a pasted secret, the conversational path won't discover much. API key / bearer / basic auth are the supported schemes — a fully OAuth-only API is a poor fit.
• Test in a sandbox first. Because the builder hits the live service to learn, point it at a test or staging key while you're exploring. You don't want endpoint discovery firing real POSTs against production, even though writes default to confirmation.
• AI-discovered endpoints still deserve a human read. The builder is excellent at the common cases; for an unusual body shape or a non-standard pagination scheme, drop into the manual editor and tune it. Treat the AI output as a strong first draft, not gospel.
• Plan limits apply. Custom API tools are a metered resource — the Professional plan includes the AI Agent Builder & Tool Builder with a set allotment of custom API tools, and Enterprise raises the ceiling. If you're connecting dozens of internal services, check the pricing page for the current limits.
• It's not a replacement for a real integration. For a high-volume, mission-critical system you'll lean on Macha's native connectors (or a maintained MCP server) over a hand-built tool group. The Tool Builder shines for the long tail of internal and niche APIs that no vendor will ever build a first-class connector for.

Where it fits in the Macha stack

The Tool Builder is one of three "describe it and Macha builds it" capabilities that shipped in this window — alongside the AI Agent Builder (build a whole agent from a description) and Studies (run an AI analysis across thousands of tickets). Together they push the same idea: the configuration surface of an agent platform should be a conversation, and the system should be allowed to test its own work before you trust it. For teams running Macha as the agent layer on top of Zendesk or Freshdesk, the Tool Builder is what lets a generic support agent reach into the one system that makes your business yours.

FAQ

What kind of APIs can I connect? Any REST API that authenticates with an API key, bearer token, or basic auth. You describe it in the builder, paste the credential, and Macha discovers and tests the endpoints. APIs that require a full OAuth flow Macha can't complete from a pasted secret aren't a fit for the conversational path.

Do I need to write any code or upload an OpenAPI spec? No. The AI Tool Builder works from a plain-language description plus a working credential — it doesn't require a spec file or glue code. If you want precise control, the manual Custom API Tool editor is there for hand-built requests.

How does Macha keep destructive actions safe? The builder auto-detects the HTTP method: POST, PUT, PATCH, and DELETE are automatically marked as write operations that require confirmation, so an agent can't mutate data without an explicit go-ahead. GET (read-only) tools run freely.

Are my API credentials secure? Credentials are encrypted at rest, and the edit modal shows only a masked hint of the configured key — never the full secret.

Does using a custom tool cost credits? Yes — a tool call is an AI action, so it draws on your credit balance like any other agent action, at the per-action rate of the model you've assigned (default GPT-5.4 Mini = 1 credit). See the pricing page for details.

Which plans include the Tool Builder? The AI Agent Builder & Tool Builder are included on Professional and Enterprise, with a set number of custom API tools per plan (Enterprise allows more). Check pricing for the current allotments.

Try it

If your agents keep hitting a wall at the edge of your native connectors, the AI Tool Builder is the bridge. Start a 7-day free trial, no credit card required, open the Custom Tools area, and describe the API you've always wanted your agents to reach — or read the Custom Tools docs for the full walkthrough.

Written by Abbas (Customer Support & AI, Macha) · Reviewed by Ankeet Guha (Co-founder & CTO) · Published 2026-06-24 · Last updated 2026-06-24.