Ontheia (MCP-Client)

Ontheia — the self-hosted AI agent platform

Your Data. Your AI. Your Rules.

Every time AI work runs on someone else's infrastructure, you give up more than privacy. You give up control over data, tools, workflows, and the rules that govern how work gets done.

Ontheia gives them back. It is open source, and it keeps AI capable and connected — within boundaries you set.

Most AI setups stay fragmented: separate chats, tools, scripts, and automations with no shared memory, no continuity, and no operational boundaries. Ontheia brings specialized agents, tools, memory, scheduling, and delegation into one governed work context — on your own infrastructure.

→ ontheia.ai · Documentation · Blog

---

At a glance

• 🖥️ Self-hosted — Runs on your own infrastructure. Docker-based, easy to deploy.
• 🔌 Multi-provider — Claude, GPT, Grok, Gemini, Ollama — you choose the model. No lock-in.
• 👥 Multi-user — Role-based access control, teams, and projects — built for organizations.
• 🔗 MCP-native — Built on the open Model Context Protocol — connect agents to any external tool.
• 🧩 Skills — Knowledge and workflows as reusable modules — define once, use from any agent.
• ⏰ Cron automation — One-time or recurring jobs — set up via form or directly in chat.
• ⚙️ Workflow engine — Visual automation pipelines. Complex agent logic without code.
• 🧠 Long-term memory — Built-in RAG with pgvector. Agents remember and access your knowledge base.
• 🤝 Agent-to-agent — Agents communicate directly — complex tasks get split and coordinated.
• 🛡️ GDPR by design — Data never leaves your servers, enforced by PostgreSQL Row Level Security.

---

More than the sum of its parts

No single feature is the point. The shift comes from combining them.

An agent in Ontheia can break a request into subtasks and hand them to other specialized agents — each with its own tools, memory, and skills. They coordinate, remember across sessions, and act on their own schedule. A fresh install ships with two agents to start from: the Ontheia Guide walks you through setup, and a Personal Assistant is ready to work.

This isn't a chat UI with plugins, prompt-based automation, or a bare agent runtime — it's an operational layer for sovereign AI work: agents that use your tools, retain context, coordinate capabilities, and operate over time, all inside one system you control.

---

What's inside

• Specialized capabilities — use agents and Agent Skills instead of one generic assistant. Skills are reusable modules based on the open Agent Skills standard, and the built-in skill-creator can build and test new ones directly in chat.
• Delegation & coordination — hand work off across specialists with the delegate-to-agent tool, either autonomously or as declarative Chain steps.
• Tools & external systems — Ontheia is MCP-native, so agents can connect to tools and services over an open standard instead of proprietary integrations.
• Persistent memory you can govern — built-in RAG with pgvector, isolated by user and namespace. Entries are filed by the kind of memory they are: episodic, semantic, procedural, working, document. That is what makes memory governable rather than merely searchable.
• Workflows — the visual Chain Engine turns multi-step logic into no-code pipelines.
• Diagrams in chat — the agent writes Mermaid, the chat renders it live: flowcharts, sequence, class, ER, Gantt, state, mind maps, and more (12+ types). No render server, no export detour — a built-in skill keeps the syntax and layout clean.
• Files as artifacts, not walls of text — when an agent reads or writes a file, a card appears; one click opens it in a side panel with edit/preview, conflict-safe saving, and a built-in PDF and image viewer. Every code block in an answer carries a pencil: revise it in the panel and save it as a file. The agent stops repeating file contents in its answers and quotes only what it discusses — which also saves a substantial number of tokens.
• Scheduling — run recurring or one-time jobs automatically, including jobs that resume an existing chat where it left off.
• Vendor-agnostic — Claude, GPT, Gemini, Grok, Ollama, or any OpenAI-compatible model. Switch providers without rewriting agents.
• Reasoning models, made visible — Ontheia speaks both reasoning paths: OpenAI's Responses API, so reasoning and function tools work together where chat completions no longer allows it, and Anthropic's extended thinking. Effort is configurable per model, thinking survives across tool iterations, and a dedicated Reasoning tab in the trace panel shows what the model actually thought — not just what it answered.
• Safe file handling — a built-in files skill lets agents search, read, write, edit and move files with guarantees that make mistakes impossible, not just discouraged: writes never clobber (recoverable trash), edits need an exact match, and concurrent changes are caught by content hash. No config needed.
• Governance & control — self-hosted and GDPR-compliant by design — data never leaves your servers. Role-based access enforced with PostgreSQL Row Level Security; you decide per agent which model can access which data. In multi-user setups, per-user file access is enforced server-side — one user's agents can't reach another's files.

---

How it works

flowchart TB
    subgraph infra["🔒 Your Infrastructure"]
        UI[WebUI / Chat] --> A1[Agent]
        A1 --- SK[Skills]
        A1 --- MEM[Memory / RAG]
        MEM --- DB[(PostgreSQL + pgvector)]
        A1 -->|delegate-to-agent| A2[Sub-Agent]
        A1 --> CE[Chain Engine]
        A1 --> SCH[Scheduler]
        A1 --> TOOLS[MCP Tools / External Systems]
        A1 --> OLLAMA[Ollama<br/>local models]
    end
    A1 -.-> PROV[Cloud AI Providers<br/>Claude · GPT · Gemini · Grok]

    classDef external fill:#fff3cd,stroke:#d4a017,stroke-width:1px,color:#5c4400,font-weight:bold;
    class PROV external;

Everything that matters — chat history, memory, skills, workflows, schedules, tool connections — stays inside your infrastructure. Only the model inference call crosses the boundary, and you choose which provider gets it.

---

Screenshots

What can I use Ontheia for?	Exa search → PDF summary → email — in one step.
Describe a process — Ontheia renders it as a flowchart.	Turn a project brief into a structured mind map.

---

Requirements

Requirement	Minimum	Notes
OS	Linux / macOS	Windows via WSL2
Docker	24+	Rootless mode recommended
Docker Compose	v2 (plugin)	docker compose (not docker-compose)
RAM	2 GB	4 GB recommended
Disk	5 GB free	10 GB recommended
Ports	8080, 5173	Configurable during setup
openssl	any	For secret generation (apt install openssl)
curl	any	For health checks
jq	any	For JSON parsing (apt install jq)

At least one AI provider API key is required to chat (e.g. Anthropic, OpenAI, or a local Ollama instance). Memory/RAG features additionally require an embedding-capable provider.

---

Quick Start

Guided setup (recommended) — one command, configures everything interactively:

curl -fsSL https://get.ontheia.ai | bash

This downloads Ontheia to ~/ontheia and runs the installer, which handles .env creation, secret generation, Docker builds, database migrations, and bootstraps the first admin account.

Prefer to inspect the script first? Clone and run it from the repository:

git clone https://github.com/Ontheia/ontheia.git
cd ontheia
bash scripts/install.sh

Manual setup:

git clone https://github.com/Ontheia/ontheia.git
cd ontheia
cp .env.example .env    # Edit .env — set FLYWAY_PASSWORD, ONTHEIA_APP_PASSWORD, ADMIN_EMAIL
docker compose up -d

Open Ontheia:

Visit http://localhost:5173 in your browser.

Full installation guide: docs.ontheia.ai/en/getting-started/02_installation

Update:

scripts/update.sh pulls the latest version, rebuilds the containers, applies database migrations, and brings the stack back up — in one step. Your data, configuration, and .env stay untouched:

bash scripts/update.sh

Uninstall:

Remove the entire stack — containers, volumes (including the database), images, and the install directory. Your ~/.claude, ~/.gemini, and NVM directories are never touched. --keep-data stops the stack but keeps volumes and configuration:

bash scripts/uninstall.sh               # interactive, asks for confirmation
bash scripts/uninstall.sh --keep-data   # stop everything, keep the data

---

Documentation

Full documentation at docs.ontheia.ai

Topic	EN	DE
Introduction	EN	DE
Installation	EN	DE
Environment variables	EN	DE
Agents	EN	DE
Agent Skills	EN	DE
Chain Engine	EN	DE
Memory / RAG	EN	DE
Security	EN	DE
Automation	EN	DE
API Reference	EN	DE

---

Stack

• Backend: Node.js / TypeScript (Fastify)
• Frontend: React, shadcn/ui, Tailwind CSS
• Database: PostgreSQL with pgvector extension
• Containerization: Docker, Docker Compose (rootless)
• AI Protocols: Anthropic Messages API, OpenAI-compatible API, MCP (Model Context Protocol)
• REST API: the entire feature set — chats, runs, agents, skills, memory, chains, automation, artifacts, admin — is exposed as a documented REST API with Bearer-token auth, so scripts and custom clients get everything the WebUI gets

---

Roadmap

See ROADMAP.md for planned features across all horizons.

Community input is welcome — open an issue or start a discussion.

---

Contributing

Contributions are welcome.

1. Fork the repository
2. Create a feature branch
3. Submit a pull request

Please read CONTRIBUTING.md before opening a pull request.

If Ontheia resonates with you, a ⭐ helps others find it — and helps us build a community around sovereign AI.

---

License

Ontheia is dual-licensed:

1. Open Source: GNU Affero General Public License v3.0 — free for personal use, self-hosted deployments, and open-source projects.
2. Commercial: Commercial License — for organizations that need to use Ontheia without AGPL obligations (e.g. as part of a proprietary product or managed service). Contact us via ontheia.ai for inquiries.

---

Contact

• Website: ontheia.ai
• GitHub Discussions: github.com/Ontheia/ontheia/discussions

---

© 2026 Ontheia · Open source under AGPL-3.0.