I built a self-hosted, multi-agent AI platform you can point at your own infra

Parendum — Tue, 23 Jun 2026 13:00:00 +0000

Every "AI agent platform" I wanted to use was a hosted SaaS. That's a non-starter the moment your agents need to touch production infrastructure, internal data, or customer records — you can't hand that to someone else's cloud.

So we built Nexora: a multi-agent orchestration platform that runs entirely on your own infrastructure. The core is MIT-licensed and free to self-host. This post is the "what we built and why" — the architecture, the provider abstraction, and the honest current state.

The gap it fills

There are roughly two kinds of "agent" tools out there:

A library (LangChain-style) — you still have to build the product around it: auth, multi-tenancy, a UI, tool management, streaming, persistence.
A hosted cloud — a finished product, but you can't point it at your own infra or run it air-gapped.

Nexora is the missing middle: a finished product you self-host. Web UI, terminal client, mobile app, multi-tenant auth, a tool/skill system, and a marketplace — all running on your box.

What it does

Multi-agent orchestration — agents have personas, skills, and tools. They chat in real time, decompose work into tasks, spawn bounded sub-agents, and stream results over WebSocket (or SSE).
~46 LLM providers behind one interface — Claude, Gemini, OpenAI, Ollama, Bedrock, Azure, Vertex, Groq, Mistral, xAI, and more. Mix cloud and fully local (Ollama/LMStudio) per agent, with no vendor lock-in.
~90 built-in tools / ~15 skills — Slack, Jira, Linear, Notion, PagerDuty, Kubernetes, Google Drive, S3, Playwright, and a hardened HTTP tool with an SSRF allowlist.
Knowledge base / RAG on pgvector + semantic memory + multimodal image input.
Three clients, one instance — a Next.js web UI, a Go + Bubble Tea terminal client, and an Expo mobile app that QR-pairs to your server.

The architecture, briefly

The stack is deliberately boring and self-hostable:

FastAPI (async) + SQLAlchemy 2   →  orchestration, providers, tools, RAG, auth
PostgreSQL 16 + pgvector         →  data + embeddings (RAG + semantic memory)
Redis 7                          →  pub/sub fan-out for real-time streaming
Next.js 15 + TypeScript          →  web UI (React Flow agent graph)
nginx + Docker Compose           →  one-command deploy

The piece I'm happiest with is the provider abstraction. Every provider — cloud API, local server, or CLI-based (Claude Code / Gemini / Codex running as a subprocess) — implements the same streaming contract. A provider chain falls back provider-to-provider on failure, so you can put a cheap local model first and a frontier model as backup, per agent.

Spinning it up is a Compose stack:

git clone https://github.com/ParendumOU/Nexora.git
cd Nexora
cp .env.example .env          # set SECRET_KEY + ENCRYPTION_KEY
make dev                       # backend, frontend, nginx
docker compose exec backend alembic upgrade head

First visit with no users drops you at /setup to create the admin.

The wedge: your data never leaves

This is the whole point. With Nexora:

Your model-provider keys live in your DB (Fernet-encrypted), not a third party's.
Your agents can run fully local models, so prompts never leave the box.
Your agents' prod access (Kubernetes, S3, internal APIs) stays inside your network.

That's what makes agents usable for the work that actually matters — on-call/SRE, back-office ops, internal automation — instead of just demos.

Honest current state

I'd rather you trust the project than oversell it. It's young and moving fast. The most important thing to know before you run it: the backend can run tools and optionally spawn containers, so host and Docker isolation are yours to own — treat it like any service with shell access. The docs cover hardening, and there's a known list of items we're working through in the open.

Open-core

The core is MIT — use it, fork it, ship it. A paid Cloud edition adds the enterprise wall (SSO/SAML, SCIM, RBAC, IP allowlist, audit retention, white-label, backup/restore) for teams that need it. The agent product itself is always self-hosted.

Try it / tell me where it breaks

Repo: https://github.com/ParendumOU/Nexora
Docs: https://docs.nexora.parendum.com
CLI / mobile: https://github.com/ParendumOU/Nexora-CLI · https://github.com/ParendumOU/Nexora-Mobile

I'd especially love feedback on the self-hosting experience and the security model. If you run it behind a homelab VPN or point it at a local model, tell me what setup you used and where the provider abstraction falls short. A ⭐ on the repo helps if you want to follow along — it genuinely shapes what we build next.

DEV Community: Parendum