The full-stack platform for AI agents, agnostic by design
Import an API, get typed tools, publish them over MCP, A2A, UTCP, and Agent Skills, and run agents that mix Claude, ChatGPT, Gemini, or the models you host yourself. Open source, no lock-in.
Self-host the source or use the hosted platform. No credit card to start.
Connect over the protocol your client already speaks
Mixture of models and modes
Build one agent from several models
One agent can use several models at once: a primary that acts, reviewers from other vendors, a self-hosted model on the sensitive step. Debate across rounds with a judge, run in parallel, or chain in sequence.
reasons and calls tools
refutes the answer before it returns
runs on your own infrastructure
Agnostic by design
No lock-in at any layer of the stack
Most agent tools marry you to one model vendor or one protocol. almyty keeps the choice yours, top to bottom.
Models
Every major LLM provider: OpenAI, Anthropic, Gemini, Bedrock, Vertex, Mistral, Groq, Ollama and more. Mix them per node.
APIs
OpenAPI, GraphQL, SOAP, Protobuf, and SDKs. Bring the services you already run, legacy included.
Memory
Pluggable agent memory and embeddings. Keep state where you want it, not where a vendor dictates.
Credentials
Your own credential vault and OAuth2 flows. almyty calls your APIs with your secrets, under your control.
Protocols
MCP, A2A, UTCP, and Agent Skills from one gateway. Clients connect the way they already work.
Deployment
Self-host with Docker and Kubernetes, or use the hosted platform. The same open-source core either way.
The pipeline
Schema in, agent out
A short path takes you from an API URL to an agent your clients can call. There is no glue code in between.
API
OpenAPI · GraphQL · SOAP
Tools
Typed & auto-generated
Gateway
MCP · A2A · UTCP · Skills
Agent
Multi-LLM pipeline
Connect an API
Import OpenAPI, GraphQL, SOAP, Protobuf, or an SDK. almyty parses the schema and reads every operation it defines.
Generate tools
Each operation becomes a typed, callable tool. When you need more, hand-write HTTP, JavaScript, GraphQL, or LLM tools.
Publish a gateway
Group tools behind one authenticated endpoint and expose them over MCP, A2A, UTCP, or Agent Skills at the same time.
Build an agent
Wire LLM calls, tool calls, conditions, and loops in the visual builder. Serve the result behind an OpenAI-compatible API.
What is in the platform
Parsers, tools, gateways, and an agent runtime
Schema parsing, tool generation, protocol serving, and the agent runtime live in one Apache-2.0 codebase.
Import OpenAPI, GraphQL, SOAP, or Protobuf, or point almyty at an npm package, and every operation becomes a typed tool. Group those tools behind a gateway and serve MCP, A2A, UTCP, and Agent Skills from one URL. Agents mix models, keep memory, and talk to Slack, Discord, Telegram, email, or a webhook. The Apache core includes multi-tenant orgs, basic RBAC, a credential vault, an audit log, rate-limit and PII-filter plugins, and usage analytics. SSO, custom roles, approval policies, and audit export ship in the commercial edition.
From OpenAPI to npm packages
SOAP and Protobuf are first-class, not an afterthought. Skip schemas and turn stripe or aws-sdk into tools from the package itself.
Multi-model agents
Debate across rounds, run in parallel, or verify before the answer returns. Memory and constraints carry across runs.
Every agent protocol
One gateway serves MCP, A2A, UTCP, and Agent Skills, with OAuth 2.1 for the clients that ask for it.
Reach any channel
Slack, Discord, Telegram, WhatsApp, Teams, email, a web chat widget, or any inbound webhook.
For the CTO
Cost, access, and blast radius
Before agents go to production you need to know what they cost, who can run them, and what happens when they are wrong.
Self-host the Apache core with no license fee, or run the hosted product on flat per-seat pricing. Bring your own keys with no token markup. The same codebase either way.
Cost
- Open-source core, no license fee to self-host
- Bring your own keys, no token markup (or prepaid credits)
- Models, protocols, and deploy target stay yours
- Flat per-seat pricing on the hosted product
Access and blast radius
- Multi-tenant orgs, basic RBAC, credential vault, audit log (Apache core)
- Human-in-the-loop approvals before irreversible steps (Apache core)
- Verify gates and constraints on autonomous agents
- Rate-limit, PII-filter, and security-scanner plugins
- SSO, custom roles, multi-reviewer approval policies, and audit export in Business/Enterprise
Publish once
Connect from anything that speaks an agent protocol
The same tools are served across protocols at once, so a Claude Code session, an A2A peer, and a UTCP client all reach the gateway without you publishing it more than once.
# Add a gateway to any MCP client
claude mcp add petstore \
--transport http https://api.almyty.com/acme/petstore
# Or call an agent over the OpenAI API
curl https://api.almyty.com/agents/$ID/v1/chat/completions \
-H "Authorization: Bearer $ALMYTY_TOKEN" \
-d '{"model":"agent","messages":[…]}'For developers
Use it from the terminal, the browser, or your editor
A CLI suite that shares one login installs your tools into the AI coding agents your team already uses, runs agents on your own machine, and answers every agent on an OpenAI-compatible endpoint.
# one login, shared by every almyty CLI
$ npx @almyty/auth login
# drop a gateway's tools into your AI editor
$ npx @almyty/skills install acme/petstore
# talk to an agent right in the terminal
$ npx @almyty/chat research-botOne CLI, one login
npx @almyty/cli covers auth, agents, chat, and skills, sharing a single credential store.
Skills for your editor
@almyty/skills install drops your tools into Claude Code, Cursor, Windsurf, and others.
Expose any environment
@almyty/runner runs anywhere (laptop, cloud VM, k8s pod, Docker) and makes that environment callable by your agents: run commands, use the local tools and CLIs it detects.
Questions
The short version
What does almyty actually do?+
It turns API schemas into typed tools, publishes those tools over MCP, A2A, UTCP, and Agent Skills, and runs the agents that call them. You pick the models, memory, credentials, and where it is deployed.
Which API formats can it import?+
OpenAPI, GraphQL, SOAP/WSDL, Protobuf, and language SDKs, each with a dedicated parser. Every operation in the schema becomes a callable tool.
What is the difference between a tool, a gateway, and an agent?+
A tool is a single callable operation. A gateway is a published endpoint that exposes a set of tools over a protocol such as MCP. An agent is a pipeline that calls LLMs and tools to do a job.
Do I have to use the visual agent builder?+
No. You can publish a gateway and call the tools from your own agents or from any MCP client. The builder is there when you want almyty to run the agent too.
Can I self-host it?+
Yes. The almyty core is open source and ships with Docker Compose and Kubernetes manifests. The hosted version at app.almyty.com runs the same core; Business and Enterprise add-ons are commercially licensed, hosted or self-hosted.
How does almyty avoid lock-in?+
Models, API formats, memory backend, credential store, serving protocol, and deployment target are yours to choose. The core is Apache-2.0, so you can take it with you.
Which LLM providers are supported?+
Every major provider, including OpenAI, Anthropic, Gemini, Bedrock, Vertex, Mistral, Groq, and Ollama. A single pipeline can mix models from different providers.
Open source
Run the same platform we host
almyty is open source under Apache-2.0. The core that runs app.almyty.com is the code you can read, fork, and self-host. One container to try it, Postgres and Redis alongside.
# one container; add Postgres and Redis
$ docker run -p 3000:3000 almyty/almyty
# or the full compose stack
$ docker compose -f docker-compose.allinone.yml up -dConnect your first API
Import a schema, generate tools, and publish a gateway in a single sitting. Start on the hosted version or run the source yourself.