In university I learned about service-oriented architecture. Services discovering each other, understanding what they do, composing themselves. I loved the idea but kept wondering how that's supposed to work when computers don't actually understand anything.
Twenty years of better APIs, better protocols, better tooling. Computers still didn't get it. Then LLMs happened and that thing I'd been wondering about since university just... works. But we're sitting on decades of messy SOAP, REST, gRPC, and now five new agent protocols that don't talk to each other. Every tool makes you pick one. I wanted all of them.
Share one stdio MCP server subprocess across many concurrent clients over a Unix socket — remaps request ids, serializes writes, respawns on crash. Internal almyty plumbing.
2026-10-28
Estrellas
—
Herramientas
—
Disponibilidad
—
What almyty does
Point it at an API description (OpenAPI / Swagger, GraphQL, SOAP / WSDL, gRPC / proto) and each operation becomes a tool. Or point it at an npm package (pg, stripe, @aws-sdk/*, etc.) and almyty generates tools from the SDK surface automatically. No code needed for either path. When you do need custom logic, write sandboxed JavaScript with npm dependencies: it runs in a Node 26 worker thread with filesystem, process, and network restrictions enforced.
Build agents with a visual pipeline builder. Chain LLM calls, tool calls, conditions, loops, parallel fan-out, sub-agents. Or skip the pipeline and run autonomous agents that figure out the steps themselves. Either way, you get scheduling, webhooks, human-in-the-loop, and an OpenAI-compatible chat API.
Serve your tools through gateways: each gateway serves the tools you pick over one protocol, MCP, UTCP or Agent Skills, from its own endpoint (/{org}/{gateway}). Put an agent where people are through its channels: a web chat, a widget on your site, Slack, WhatsApp, Teams, Telegram, Discord, email, SMS, a webhook, a desktop or terminal app, and A2A for other agents. Every agent also has an OpenAI-compatible API.
Self-hosted. Your infrastructure, your data.
Quick start
For local development, install Docker with the Compose v2 plugin, then:
git clone https://github.com/almyty-inc/almyty.git
cd almyty
docker compose up --build -d
Open the UI at http://localhost:4001; the API is at http://localhost:4000. Compose builds the development images, installs their dependencies, and starts PostgreSQL and Redis too. No separate frontend process is needed. These development defaults are not suitable for a public deployment.
almyty/api + almyty/frontend: the API and the UI as separate images, for Kubernetes and scale-out deployments.
almyty/almyty: a single image that serves both the API and the UI on one origin, for simple self-hosting. The example below starts separate PostgreSQL (with pgvector) and Redis containers alongside it. From the repository root, generate secrets for a new installation:
Persist these values securely outside version control and restore them before later starts. Keep the same ENCRYPTION_KEY for an existing installation: regenerating it makes stored credentials unreadable. Existing database volumes also require their original database password. For managed services, replace the database/cache services and configure their connection settings; PostgreSQL must provide the vector extension. Configure TLS before exposing the app publicly.
Import any API schema. Each operation becomes a tool. (docs)
Build agents visually or let them run autonomously. 13 step types, 39 LLM providers. (docs)
Serve tools through gateways, one protocol each: MCP, UTCP or Agent Skills. Put agents in front of people and other agents through their channels: web chat, website widget, Slack, WhatsApp and the other messaging apps, desktop and terminal apps, and A2A. (docs)
CLI
One install, one login, every CLI works:
npm i -g @almyty/cli
almyty login # one-time browser login
Every command, through the umbrella:
almyty # short tour; `almyty help` for the full reference
almyty agents list # list agents in your org
almyty agents run my-agent --watch # run one, streaming, with cost and the model that answered
almyty chat my-agent # interactive REPL with an agent
almyty models list --selectable # model cards the router may pick
almyty models route --objective cheapest # what the router would choose, and what it passed over
almyty credentials services # what a credential can be added for, and how
almyty skills install @acme/petstore # install tools as Agent Skills into Claude Code, Cursor, etc.
almyty mcp # run almyty as an MCP server proxy
almyty acp # run almyty as an ACP agent
almyty runner start --name laptop # register this machine as a runner
almyty completion zsh # shell completion; bash and fish too
Each subcommand maps to a standalone npm package (@almyty/auth, @almyty/agents, @almyty/chat, @almyty/models, @almyty/credentials, @almyty/skills, @almyty/mcp-server, @almyty/acp-server, @almyty/runner) and the umbrella delegates to whichever you call. See the CLI docs for the full reference.
Scripting. Every read command takes --json and writes nothing but JSON to stdout. Every CLI shares one exit-code table: 0 ok, 1 unexpected, 2 usage, 3 not authenticated, 4 not found, 5 the operation ran and failed — so a script can tell a stale login from a crash from an agent that ran and returned an error. NO_COLOR and CI are honoured, and ALMYTY_NON_INTERACTIVE=1 blocks every prompt.
Debugging a run from the terminal.almyty agents inspect <agent> <runId> shows an autonomous run step by step — which model answered each step, what it cost, how long it took. almyty agents trace <agent> <execId> does the same hop by hop for a workflow execution, and flags a hop where the provider served a different model from the one requested. Both show what the router passed over and why, and a hop whose cost the provider did not report reads cost opaque rather than $0.
Versioning. The CLI packages share one version line and release together as a suite (@almyty/* 1.x). That is separate from the platform's own versioning, which is the Docker images and v0.x git tags. The two numbers moving independently is expected; newer CLI commands need the corresponding server features, so keep both current.
Skills
Install almyty tools as Agent Skills into 30 coding agents (Claude Code, Cursor, Copilot, Windsurf, …):
almyty skills install @acme/petstore
almyty skills install @acme/petstore --dry-run # show every file it would write first
MCP
Almyty serves every tool and agent as MCP at /{org}/{gateway} (Streamable HTTP). Point any MCP client at the URL and the gateway's tools are available. The @almyty/mcp-server CLI also runs almyty as a local MCP proxy if your client only speaks stdio. (docs)
Runners
A runner is a long-running daemon that registers any machine you control with almyty — your laptop, a build box, a GPU host, a server inside your own network — and runs process / shell / file work there, scoped to a workspace. Execution happens on that machine, but command results and requested output are sent back to almyty and may become agent/model context. Do not print secrets or return sensitive file contents unless you intend to share them. Tools the runner publishes appear in the catalog automatically, and agents call them like any other tool over a persistent Streamable HTTP connection.
That is the general capability. One thing it is particularly good at is driving a CLI coding agent (Claude Code, Codex, gemini, aider) against a real checkout in one coherent session.
npm i -g @almyty/cli
almyty login
almyty runner start
Login chooses your organization when you belong to several. The runner takes its machine's hostname and can be renamed later. The login identifies and authorises the runner. Who else can see and use it is its visibility: Private (the default), Team, or Org-wide.
By default the runner uses host isolation: dispatched commands run as the user who started it, on that machine. Package installs are refused by default, and allowedCwdRoots / denyPatterns narrow it further — see the runner README, which the daemon also summarizes at boot.
Or open /runners/new in the UI for a guided setup. See docs/runner.md for architecture and docs/runner-demo.md for an end-to-end walkthrough.
Development
For tests outside the containers, use Node 26+ and install dependencies from the repository root. These commands all run from that same directory:
npm --prefix backend ci
npm --prefix frontend ci
npm --prefix backend run test # default suite; DB-gated tests are skipped
npm --prefix backend run test:full # includes DB integration; needs local PostgreSQL + Redis
npm --prefix frontend run test -- --run # vitest
npm --prefix frontend run test:e2e # Playwright E2E; see prerequisites below
The database integration command uses the PostgreSQL/Redis ports from the development Compose stack. For browser installation and E2E environment setup, see the E2E test guide.
Compliance
almyty ships the operational pieces the EU AI Act asks deployers for: per-channel AI disclosure (Art. 50), human-in-the-loop approvals (Art. 14), with multi-step and quorum approval policies in the commercial edition, run/audit logging (Art. 12), and a per-agent technical-documentation export (Annex IV). The full mapping, including GDPR, CRA, and the enterprise-questionnaire regimes, lives on the docs site under Compliance. Vulnerability reporting: see SECURITY.md.
License
Apache-2.0 for the open-source core; everything under backend/ee/ is commercial (Enterprise Edition, entitlement-gated at runtime). See LICENSING.md.
Share one stdio MCP server subprocess across many concurrent clients over a Unix socket — remaps request ids, serializes writes, respawns on crash. Internal almyty plumbing.
Aún no hay lista de herramientas. Los servidores remotos la reciben tras la primera comprobación de estado.
Preguntas frecuentes
Preguntas
¿Cómo instalo @almyty/mcp Mux?
Copia en esta página la configuración stdio para Cursor, Claude Desktop, Claude Code o VS Code. Usa la instalación del publicador, no un proxy de PlugMCP.
¿@almyty/mcp Mux necesita una clave de API?
Este registro no indica ninguna variable de entorno obligatoria.
¿Qué transporte usa @almyty/mcp Mux?
@almyty/mcp Mux se ejecuta localmente por stdio.
¿Cuándo se comprobó @almyty/mcp Mux por última vez?
Última comprobación: 2026-10-28. Share one stdio MCP server subprocess across many concurrent clients over a Unix socket — remaps request ids, serializes writes, respawns on crash. Internal almyty plumbing.