For developers

An agent in your product.
Your tools in the agent.

Build an agent into your application, connect your APIs to an AI client, or put work on a machine you control. Use the builder and the APIs together, with models, memory and checks configured around the agent.

Three ways in

Start where your code meets the agent.

An agent in your application

Call a configured agent through the OpenAI-compatible API. It runs with its own tools and behavior, and returns its answer to your application.

See the API example

Your APIs in an AI client

Import an API, select its tools and publish a gateway. Connect an MCP client using the endpoint and a scoped key.

Explore the gateway setup

A job on your own machine

Connect a runner on a laptop, VM or server. Agents can request work there within the machine access and rules you configure.

See the runner commands

An agent behind your interface

Keep the behavior with the agent. Build the experience around it.

Configure its tools, memory and models in almyty. Use autonomous behavior or a workflow, add an answer check, and inspect the resulting runs. Your application calls the configured agent rather than recreating those decisions in each request.

Use an almyty platform key and an agent it may call. The compatible endpoint supports chat completions; some model API fields are intentionally unsupported. The API reference documents the contract.

Read the request contract
Python / OpenAI-compatible API
from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.almyty.com/v1",
    api_key=os.environ["ALMYTY_API_KEY"],
)

# Pick an agent this key may call.
agents = list(client.models.list())
if not agents:
    raise RuntimeError("Create an active agent first")

reply = client.chat.completions.create(
    model=agents[0].id,
    messages=[{"role": "user", "content": "What can you help with?"}],
)
print(reply.choices[0].message.content)

Building blocks

What you build with

Import API tools

Import a supported OpenAPI, GraphQL, SOAP/WSDL or gRPC description, or an npm package. Select the operations you need as tools. Add HTTP or sandboxed JavaScript tools when the integration calls for them.

Share actions with AI tools

Group actions behind a gateway and serve them over MCP, UTCP or Agent Skills, with keys per client. Add them to your coding assistant or any MCP client.

Call assistants from code

Every assistant answers on an OpenAI-compatible API. Point an OpenAI library at it, change the base URL and the model name, keep the rest.

One command line tool

@almyty/cli: log in once, then run and inspect assistants, chat with them, install skills, and more. Every read command has --json.

Runners on any machine

almyty runner start connects a laptop, VM, container or server. Assistants run commands and use local tools there, within the folders and rules you allow.

Self-host the core

The core is Apache 2.0. Run one container with Postgres and Redis, or deploy to Kubernetes. The hosted version runs the same code.

Measured

What a large API costs in context

The measurements below compare full tool definitions with almyty code mode: three entry points to search for, inspect and call the connected tools. The task traces show how much context each approach used in these scripted examples.

Tool definitions in context before the first message (tokens¹)
APIToolsPlain MCPCode mode
Open-Meteo forecast1519612
GitHub REST, issues6622,413612
Stripe, full API612409,045612
One scripted task: context at the final call (tokens¹)
APITaskPlain MCPCode mode
Open-Meteoweather in Berlin5542,102
GitHubread issue #122,4395,498
Stripelook up a customer409,0641,593

For a one-tool API, code mode costs more than plain MCP. It pays off as the API grows: about 4 times less context for the GitHub issues subset, and about 250 times less for Stripe, whose plain definitions alone are larger than a 200k-token context window.

API description to usable tools: backend time, median of 5 runs²
APIDescriptionOperationsMedian
Open-Meteo forecast134 KiB10.22 s
GitHub REST, issues317 KiB660.42 s
Stripe, full API8.1 MiB6123.66 s

How this was measured (11 November 2026)

  • ¹Tokens counted with the o200k_base tokenizer (tiktoken), for the tool definitions as they sit in context before the first message. Other tokenizers, including Claude's, give different counts and were not run. No model ran: each task's searches, scripts and arguments were scripted calls against a live almyty stack, so a model may search more or pick other arguments.
  • ²Import time is backend processing only, from upload to tools generated, measured through the HTTP API on one laptop under load (Apple M2 Pro, local Postgres and Redis). It leaves out finding the description, setting up keys, creating a gateway and any human time.
  • Three APIs, one task each; the GitHub description is a 66-operation subset of the full API.

Method, raw data and limits: benchmarks/results.md. Reproduce with npm run bench in the repository.

your editor
# a gateway's actions in any MCP client's config
{ "mcpServers": { "weather": {
    "url": "https://api.almyty.com/your-org/weather",
    "headers": { "x-api-key": "gw_live_..." }
} } }
terminal
$ npm i -g @almyty/cli
$ almyty login
$ almyty agents run site-weather-brief --watch
$ almyty chat site-weather-brief
$ almyty runner start
A gateway's endpoint URL, which tools apps see, and who can use it.
Staging demo workspace: real public APIs, real runs
self-host
# one container for the app; Postgres and Redis alongside
$ docker compose -f docker-compose.allinone.yml up -d

# or the development stack from the repository
$ git clone https://github.com/almyty-inc/almyty
$ docker compose up --build -d

Your infrastructure, the same product

The source is public on GitHub. Images are on Docker Hub. Business and Enterprise features are licensed separately and work on your own servers too.

Bring one integration you want to build.

Create the agent, connect a tool and make a call from the application or AI client you already use.