Callables vs Retool: internal tools from Python, or from a UI builder
Retool is the best-known way to build internal tools, and for good reason. You drag tables, forms and buttons onto a canvas, wire them to your database and APIs, and ship an admin panel in an afternoon. If the job is "a screen where support can search customers, edit a record and see their orders", Retool does it very well.
A lot of internal tooling isn't screen-shaped, though. It's a Python script someone runs for you: issue a refund with a reason, export last month's signups, merge two CSVs, re-sync an account. For that, building a UI around the script is extra work. That's where Callables fits.
Different starting points
Retool starts from the interface. You lay out components, then attach queries to them: SQL against a database, REST or GraphQL calls, and JavaScript to transform data and handle events. Retool Workflows add backend jobs with code blocks, including Python, for scheduled and triggered work.
Callables starts from a function. You write Python in your own repo, add @deploy, and push:
from typing import Literal
from callables import deploy
@deploy(title="Refund an order", secrets=["STRIPE_KEY"])
def refund(
order_id: str,
reason: Literal["Damaged", "Late", "Other"],
notify_customer: bool = True,
) -> str:
"""Refunds the order in Stripe and records why."""
...
return f"Refunded {order_id}"Callables turns the signature into a form: a text box, a dropdown and a checkbox. There's no UI to lay out, and anything Python can do, the function can do, with any package from PyPI.
Where each one is stronger
Retool is stronger at rich interfaces. Editable tables, multi-step screens, charts beside forms, custom layouts, mobile apps: if people spend their day in the tool, a UI builder gives you control Callables doesn't try to. It also connects to many databases and SaaS tools out of the box.
Callables is stronger when the logic is the hard part. When the tool is a few hundred lines of Python with real logic in it, Callables lets you keep that code as normal code: in your repo, reviewed in pull requests, tested with pytest and written with your AI coding agent. Every push deploys. Results show as formatted text, tables people can download, or files. Every run is saved with its inputs, logs and result, so "did the refund go through?" is answered by the run history.
Callables is also built for agents. Your functions are available over MCP, so Claude, Cursor or any MCP client can find and run them with the same permissions you set for people, and an agent can write and deploy new functions too.
Code and review
In Retool, apps are built and stored in Retool's editor, with queries and JavaScript inside each app. Retool offers Git-based source control on its higher plans.
In Callables, everything is your code from the start. There's nothing to export or sync: the repo is the tool. Rolling back means deploying an earlier commit.
Sharing and access
Both let you control who can use what. In Retool, permissions are set per app and per group. In Callables, you decide who can run or manage each function, secrets are scoped to the workspace, project or function, and the people running a function never see its secrets or its code.
Pricing
Retool charges per user, with different prices for people who build apps and people who only use them. As of November 2026, its Team plan is $10 per builder and $5 per end user per month billed annually ($12 and $7 monthly), and Business is $50 per builder and $15 per end user. A team of 3 builders and 30 users on Team is about $180 a month. Check Retool's pricing for current figures.
Callables charges per workspace plus the compute your runs use, with no per-seat price on Pro. Pro is $20 a month with $20 of usage included, and Hobby is $5 a month. Thirty people running functions cost the same as three. See pricing.
At a glance
| Callables | Retool | |
|---|---|---|
| Built with | Python functions in your repo | A drag-and-drop editor, SQL and JavaScript |
| The UI | Generated from type hints | Designed by you |
| Best for | Script-shaped tasks: run a job with inputs, get a result | Screens people work in all day |
| Backend logic | Any Python and PyPI package | Queries, JavaScript, and Python in Workflows |
| Version control | Git from the start; every push deploys | Built-in history; Git on higher plans |
| Run history | Every run with inputs, logs and result | Audit logs on higher plans |
| AI agents | Functions available over MCP | Retool's own AI features |
| Pricing | Per workspace plus compute; no per-seat price on Pro | Per builder and per end user |
Which one to use
Use Retool when you need a custom interface: a dashboard, an editable table, a multi-screen app people live in.
Use Callables when the tool is really a script: a job with inputs and a result, written in Python, that your team needs to run safely without you. Many teams use both, with Retool for the screens and Callables for the jobs behind them.
Weighing other options? See Callables vs Windmill and Airplane, Callables vs Streamlit and building an internal admin panel in Python.
Turn your scripts into tools your team can run
Add @deploy to a Python function and push. Your team gets a form, schedules and run history.
Keep reading
Callables vs Windmill and Airplane: a repo-first alternative
How Callables compares to Windmill, and where Airplane users can go now. Same goal, different starting point: your repo, your editor, your agent.
GuidesBuild an internal admin panel in Python
Search for a record, then act on it from buttons on each row. Chain Python functions into step-by-step tools your support and ops teams can use.
ComparisonsCallables vs Streamlit: data apps or team tools from Python
Streamlit builds interactive data apps from a Python script. Callables turns Python functions into tools a team runs, with schedules and run history. How they differ and when to use each.
