Use your email or service name to access the operator dashboard.
Create a service account. You will receive a verification email, then your request will be reviewed before you can sign in.
Verifying your email address…
Boost inference from the mesh when you need more power — share yours when you don’t.
Designed to scale agent workloads across peers you choose — no mandatory cloud inference. Public Beta — features may change. Terms & Privacy.
Install mtrxAI, point your tools at it, and join a private team, a public regional cluster, or a small invited group. Hardware sharing is always optional.
Built to scale agents across peers without requiring a cloud. Pull the container, join a cluster or swarm, point your apps at the local proxy.
View on Docker HubDesktop builds are CLI peer binaries (v0.4.0). Public Beta — features may change. Terms & Privacy.
mtrxAI sits between your apps and the mesh. Here is what happens in plain language.
Run mtrxAI on each machine you want in the mesh — Docker today; desktop and Android builds are coming.
Tell your AI tools to use the local mtrxAI endpoint. Same OpenAI-style setup you already know.
If the model is on your machine, inference stays local — fastest path, nothing leaves your computer.
If the model is not local, mtrxAI finds a computer in your cluster or swarm that has it, and that peer runs the request.
Two ways to connect — you can use both at once.
Invite-only or regional groups with discovery, ranking, and credit tracking so everyone can see who used what.
High-trust circles that join with a shared token. No central ledger — just peers helping each other.
Want the protocol detail? See Architecture.
Everything you need to run models locally, join private or public meshes, and keep control of your hardware.
Talk to local and mesh models from the dashboard, with saved sessions you can reopen later.
Point Cursor, agents, and other tools at localhost. Streaming and tool calling work as usual.
If the model is on your GPU, the workload stays there — zero network delay.
When you need remote help, mtrxAI prefers nearby machines and lighter load.
Managed teams with credits, or token-joined small groups — run both at the same time.
Invite-only private clusters, or join a public regional community when you want a wider mesh.
Approve who connects, block bad actors, and report abuse for operator review.
See usage history. Credits settle when both sides agree. Beta tokens have no monetary value.
Attach and manage your local engines from one dashboard — scan, attach, detach, and health-check every backend in a single place.
Pull and load models from your engines or a Hugging Face catalog. Wake an idle model on a peer with enough VRAM when you need it remotely.
Choose which models are shared with your cluster or swarm. Keep some local-only; expose others to teammates without opening the whole machine.
Sharing schedules, GPU thermal pause, and disconnect/pause for the whole node when you need the hardware back.
For API details, see For developers. For private and public teams, see Clusters.
Hardware, servers, chat, peers, activity, and model pulls — click any screenshot to expand.
Pull mtrxAI from Docker Hub and register your device in the dashboard.
Create or join a private team, a public regional cluster, or a small group with a shared token.
Connect your local model engines. mtrxAI merges them into one catalog for your apps.
Redirect AI tools to the local proxy. Sharing hardware is optional — approve each request or stay isolated.
One local gateway for your stack. Use teammates’ models without copying multi-gigabyte weights.
Offload heavy inference to a peer when local hardware is tight, then switch back instantly.
Share idle GPU time and earn credits for when you need external compute.
Isolated private clusters — internal models hidden from public discovery.
Join a private invite-only team or a public regional mesh. Models stay on the machines that load them; your apps keep talking to localhost.
Invite-only. Join with name, ID, and password from the dashboard. Models and membership stay invisible to the public mesh — ideal for teams and offices.
Regional communities listed by the lobby. Anyone approved on the network can join to borrow or share compute with a wider set of peers — treat membership accordingly.
Both types use the same routing: local first, then a peer in that cluster. Credits and ranking apply on the cluster path. You can belong to more than one cluster at once, and run swarms alongside them.
Install mtrxAI on each machine, join the same cluster, and point your applications at the local proxy. When a model isn’t local, mtrxAI routes the request to a peer in that cluster.
mtrxAI helps the two computers find each other. Once connected, prompts and replies travel directly between them. If a direct path cannot be opened, mtrxAI can relay the connection.
Develop on a light laptop while heavy models run on a rig with enough VRAM. Your IDE still targets the local proxy.
Link several workstations in a private cluster. Shared models stay off the public list; nearby peers are preferred automatically.
Join a public regional cluster to reach more peers when your private team is offline or short on VRAM.
On a GPU machine, create a private cluster — or browse and join a public regional one from the dashboard.
For private clusters, copy the invite details (name, ID, password). For public ones, select the region and connect. Each machine gets its own identity.
Attach engines, set per-model visibility, and connect. Remote models from that cluster appear in your local catalog.
Private invites: you will copy cluster name, ID, and password — enough for teammates to join the same team.
For how discovery and transport work under the hood, see Architecture.
You control visibility, sharing, and who connects. Inference travels peer-to-peer with transport encryption and application-layer end-to-end encryption enabled by default.
Outsiders cannot discover your node unless they are in the same cluster or swarm. Private clusters stay invite-only.
Choose which models to expose, approve incoming requests, set sharing schedules, or pause and disconnect the whole node anytime.
Block misbehaving peers locally and submit signed behavior logs for operator review.
Disconnect or pause all network links instantly when you need your machine back.
Prompts and completions are encrypted between peers. The lobby helps with discovery and signaling — it is not on the inference data path.
Enabled by default (MTRXAI_E2EE_ENABLED). Proxy requests and responses use ChaCha20-Poly1305 AEAD after an ephemeral X25519 ECDH session. Plaintext proxy protocol v1 is rejected when E2EE is on.
A room root key is derived from the cluster or swarm secret. Per request, peers negotiate an ephemeral session key (HKDF) so payloads are not readable by relays or the lobby.
Transport uses DTLS on the data channel. On top of that, encrypted proxy frames (EncryptedProxyRequest / response) carry the inference payload when E2EE is enabled.
Transport uses Noise. Proxy protocol v2 adds the same ChaCha20-Poly1305 E2EE layer, plus HMAC-based ProxyAuthProof membership checks (replay window ~300s).
Cluster links: WebRTC DTLS/SRTP. Swarm links: libp2p Noise over TCP. Wire encryption protects bytes in transit; app E2EE keeps prompts opaque to anyone who is not a session endpoint.
Each machine carries an Ed25519 device key. The lobby can require attested client builds via challenge-response before registration.
Optional sealed icell runs the model engine beside the peer. Attestation can cover the cell so teams verify more than just the peer binary.
Lobby WebSocket carries discovery, SDP/ICE signaling, and credit reports — not prompts or completions. Short-lived TURN credentials may be minted for NAT relay; prefer TLS (wss://) to the lobby in production.
The OpenAI-compatible proxy defaults to 127.0.0.1. Optional bearer token (MTRXAI_PROXY_TOKEN) can lock down local LLM routes.
On clusters, credits settle only when consumer and provider report matching usage. Mismatches reject the transaction. Beta tokens have no monetary value.
Room keys, API keys, and transaction history live in the peer’s local encrypted store — not in the lobby catalog.
On supported hardware, providers can advertise TEE / confidential computing trust levels. Consumers can prefer or require attested GPU environments. Optional inference sidecar keeps the P2P relay blind to plaintext.
Beta notice: Do not route regulated or highly confidential data through public clusters. Membership on a public cluster is weaker than a password-protected private cluster — treat public peers accordingly. See Terms & Privacy.
How discovery, transport, and settlement work under the hood. For a plain-language path, start with How it works.
Mix topologies concurrently — regional clusters for discovery and credits, swarms for small trust circles.
| Managed clusters | Decentralized swarms | |
|---|---|---|
| Primary use | Teams and regional communities with discovery, ranking, and credit tracking. | Small high-trust groups with minimal central coordination. |
| Joining | Public regional index or private cluster (name + UUID + password). | Shared cryptographic Swarm token. |
| Economics | Transparent credit accounting between peers. | Honor system — no ledger. |
| Transport | Lobby signaling, then direct WebRTC data channels (DTLS). TURN relay when needed. | libp2p gossip — decentralized coordination with application-layer E2EE. |
| Network setup | No inbound ports; STUN/ICE hole punching, TURN fallback. | libp2p hole punching with optional relay fallback. |
The lobby helps peers find each other and exchange connection metadata. It does not carry inference payloads.
Usage reports reconcile on the lobby ledger when both peers agree.
The lobby can mint short-lived TURN credentials so WebRTC sessions succeed behind restrictive NAT.
One OpenAI-compatible API on localhost. Attach the engines you already run; mtrxAI routes to local hardware or the mesh.
Point tools at the local proxy (default localhost:11345). Use standard /v1/chat/completions and related routes.
Streaming responses, tool calling, and structured JSON work with agent stacks that speak OpenAI Chat Completions.
Local models and mesh models appear in one list. Local-first routing; remote only when needed.
mtrxAI talks to backends — it does not replace them. Connect what you already use:
Apps always see the OpenAI-compatible surface on the peer. Engine choice is configuration, not a second public API.
Pull the Docker image, open the dashboard, and point your client at the local proxy base URL.
Docker Hub