The full-stack platform for AI agents, agnostic by design
almyty sits on top of Claude, ChatGPT, Gemini, and the open-source models you self-host. Build one agent from several of them, give it your APIs as tools, and serve it over MCP, A2A, UTCP, and Agent Skills. 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
almyty sits on top of Claude, ChatGPT, Gemini, Mistral, and the open-source models you self-host. You do not pick one. You compose them: one model reasons, another refutes its answer, a self-hosted one handles the sensitive step. Or have several models work as a team — 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
The whole toolchain, not just a wrapper
Schema parsing, tool generation, gateways, the agent runtime, and the operational pieces around them all live in one open codebase.
From OpenAPI to npm packages
OpenAPI and GraphQL, but also SOAP and Protobuf — the legacy services too. Or skip schemas and turn an npm package (stripe, aws-sdk) straight into tools.
Multi-model, with modes like debate
Autonomous agents that mix models and collaborate — debate across rounds, run in parallel, or verify each other before the answer returns — with memory and constraints 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.
Any LLM provider
OpenAI, Anthropic, Gemini, Bedrock, Vertex, Mistral, Groq, Ollama, and more. A single pipeline can mix providers.
Reach any channel
Reach people on Slack, Discord, Telegram, WhatsApp, Teams, email, a web chat widget, or any inbound webhook.
Built to run in production
Multi-tenant orgs and RBAC, a credential vault, audit logging, rate-limit and PII-filter plugins, and a usage analytics suite.
For the CTO
Lower TCO, real governance, less risk
Before agents touch production, three questions decide it: what does it cost over time, who is allowed to do what, and how do we keep it from doing damage. almyty answers all three.
Lower TCO
- Open-source core — self-host with no license fee
- Bring your own keys, no token markup (or prepaid credits)
- Agnostic at every layer — no vendor lock-in, take it with you
- Flat per-seat pricing, predictable as you grow
Governance
- Multi-tenant orgs with role-based access control
- Audit log of sensitive actions
- Human-in-the-loop approvals before irreversible steps
- Credential vault — your secrets stay yours
Risk mitigation
- Verify gates review output before it returns
- Constraints stop agents repeating past mistakes
- PII-filter and security-scanner plugins
- Self-host or private cloud for data residency
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 is the full-stack platform for AI agents: it turns any API schema into typed tools, serves those tools over MCP, A2A, UTCP, and Agent Skills, and runs the multi-LLM agents that use them. It stays agnostic at every layer, so your models, memory, credentials, and deployment target are your choice.
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; governance and Enterprise features are commercially licensed, hosted or self-hosted.
How does almyty avoid lock-in?+
It stays agnostic at every layer. Models, API formats, memory backend, credential store, serving protocol, and deployment target are all your choice, and the platform is open source, 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.