One hub for every
AI tool you use
palaia is a self-hosted hub where every assistant you run connects once and shares one memory, one toolbox, and one way to reach each other.
Turn your AI agents into one team.
Works with the AI apps you already run
Every AI starts from zero.
Run more than one AI assistant and you set each one up on its own: its own logins, its own settings, its own memory. Tell one agent something on Monday and the next has never heard of it on Tuesday.
Every assistant wired up on its own, settings in a dozen places. What one learns, the others never see.
Each agent connects once to your hub. What one learns, they all know.
One hub. One shared memory. Every AI in sync.
The AI tools you already use.
One address for everything that speaks the Model Context Protocol (MCP). Each client has a short guide: sign in, and it is talking to your hub.
A hub, not a plugin.
Grouped by what it does for you, not by which part it lives in. Everything here ships today.
Memory that outlives the session
A Markdown knowledge base you own
One note per thing, with links between them. Obsidian opens it as it is. No account to be locked out of.
Every change is a real git commit
Written by the hub with a meaningful message: which agent, which app, why. git log is your history; git revert is your undo.
Search that finds meaning
Full text and meaning-based recall, so "pick up where we left off" actually works. Local embedding models are optional; without them it falls back to plain text search cleanly.
An inbox and a curator
Agents drop what they learn mid-work; a curator files, merges and cleans it up. Adding is automatic. Rewriting or retiring a note is only ever a proposal you approve.
Connect every AI tool, once
One address for every assistant
Claude Code, Claude Desktop, claude.ai, ChatGPT, Codex, Gemini, Grok, LM Studio, and anything else that speaks MCP.
A one-click desktop bundle
Download, click, connected. No address to type, no token to paste.
Real sign-in, not a shared secret
Sign in with GitHub or your company's OpenID Connect provider, backed by a full OAuth server. Clients that don't do OAuth get their own token instead.
A toolset per device
Give your phone a narrow set and your desktop everything, from one place, with nothing to configure on the client. Each set is its own address.
Add-ons, and automations
Install a tool once for every AI
A catalog in the dashboard built from the official MCP registry, plus any MCP server you add by hand, with its credentials in an encrypted store you fill in once.
Rules that react to what happens
A new note, a recall, a message, an idle session: turn any of it into a notification, a tool run or a memory write.
An SDK for add-on authors
Build your own add-ons with an open-source SDK, including local testing.
Multi-agent coordination
A session directory
One AI agent can find another already working on something related, by what it is doing, never by a name someone hardcoded.
Clean hand-offs
Messages between agents, including a hand-off that points at a memory instead of copying the whole text.
A team screen
See which agents are doing what, and let them check their inbox and pick up work on their own.
Operations you can live with
A dashboard that is the product
Setup wizard, memory explorer, connect pages, add-ons, health, plus in-chat apps so some of it never needs a browser tab.
One-click backup, offline restore
Back up the whole hub in a click. The restore is documented and works with no internet.
A hardened container
Non-root, no extra permissions, read-only files, with release channels and an update check built into the dashboard.
Add one add-on. Every AI has it.
Install a tool from the dashboard once and every connected AI can use it. Nothing is added until you confirm.
Browse and install
The dashboard lists servers from the official MCP registry, each showing who published it and whether palaia has reviewed it.
Any MCP server
Add any Model Context Protocol server by its address and its tools appear for every connected AI, credentials kept encrypted.
Build your own
Package your own tool with the open-source SDK and test it locally.
Decide how far it reaches.
You pick the reach in the setup wizard and the hub keeps to it. It is not a setting you have to watch.
Locked
Your machine and your own network only. Nothing leaves the house.
Cloud
Your memory is reachable from the internet through a tunnel, sign-in required, so web assistants like claude.ai and ChatGPT can reach it. The dashboard stays on your network.
Open
Deliberately public, with real sign-in in front of it, for when you mean it.
Two claims, both tested.
Each one is checked from start to finish by a test that runs a real hub over a real connection, not just described.
Install a tool once. Every AI already has it.
One add-on install; two AI assistants with different logins, on different profiles; nothing set up on either side. Both see the new add-on and both can use it.
What one agent learns, the next already knows.
From an empty hub, one agent connects and writes a fact, and a second agent on a different login recalls that exact fact. Under 13 seconds, twice in a row, with nothing changed in between.
Both ship in 3.0 and are covered by the test suite.
From scattered to shared.
A config file for every AI app and every service, each with its own syntax, its own logins, its own update cycle.
Each assistant connects once to the hub. Each add-on is installed once, for all of them.
What you tell one assistant is lost to the rest. Monday's decision never reaches Tuesday's agent.
One shared memory every agent reads and writes. What one learns, every agent knows.
Your memory lives in someone else's cloud, behind an account you can be locked out of.
A folder of plain files on your own hardware. git log is the history; git revert is the undo.
All or nothing exposure, or a tangle of firewall rules you are not quite sure about.
Locked, Cloud or Open, chosen in a wizard and kept by the hub.
Running in about a minute.
Run the hub
One command on any machine you own: a spare box, a NAS, a Raspberry Pi, a small cloud server. Docker is the whole prerequisite.
docker run -d --name palaia \
--network host -e PALAIA_CLOUD_BIND=127.0.0.1 \
-v palaia_home:/data \
--restart unless-stopped \
--security-opt no-new-privileges:true --cap-drop ALL \
--read-only --tmpfs /tmp --tmpfs /run \
ghcr.io/byte5ai/palaia:stableDocker Desktop on Mac or Windows, Compose, Synology, Umbrel, Raspberry Pi and cloud servers each have their own command on the onboarding page.
Open your hub
Go to http://palaia.local:8420 on the same network and a setup wizard takes over: say how you'll use palaia, create your first memory, set up your account. No config files, no second command.
Connect your first AI tool
Pick an assistant, follow its short guide, and it is talking to your hub behind a real sign-in. Add the rest whenever you like.
What one learns, all know
From here every AI you connect reads and writes the same shared memory. Tell one; the next already knows.
Every platform, step by step
The parts that matter.
Give every AI one shared memory.
One hub on your own hardware. Every agent connects once. What one learns, all know.
Set palaia up for me. First read all of get.palaia.ai/skill. If you can run commands, use curl, since a web fetch may only give you a summary. Then walk me through it step by step. I'm not technical, so explain everything simply.
Works in Claude, ChatGPT or Gemini. The assistant asks where palaia should run and does the rest.