openagentics

Your own AI platform.
One command to run it.

Chat, code, and visual workflows that do the work — running on your models, your infrastructure, your data. Open source. Self-hosted. Free to run forever.

see it running → read the docs ★ star on GitHub
curl -sSL https://install.openagentics.io | bash

Not just for IT ops

If you can wire it to a tool, an agent can run it.

OpenAgentic isn’t a single-purpose bot. It’s the engine — chat, flows, and code over any model and any MCP tool you connect. Point it at your systems and it works the job, whatever the job is.

Three familiar surfaces, one platform, infinite obsession

One place to run agents against your real systems.

Chat

Talk to your whole stack

Ask in plain language. It reads metrics, logs, and clusters — and acts through real tools, behind a human-in-the-loop gate on anything that mutates.

Flows

No-code visual runbooks

Wire agents and tools into governed automations — parallel fan-out, retries, approval gates, and a signed, replay-verifiable trace for every run.

Code

Wire in your repos and your tools

Reach your real repositories through the built-in GitHub tool, and connect any MCP server you bring — the agent reasons over code and runs the tools you wire up, behind the same approval gate.

Any model

Ollama · Bedrock · Vertex · Azure · OpenAI — swap per task

Your boundary

Self-hosted, air-gapped if you want — nothing leaves

Local-auth, single operator

OSS runs on a local admin account — no phone-home, no telemetry

Provable

Tamper-evident audit trail, human-in-the-loop on writes

Under the hood

Not a chat box in front of a model. The engine behind it.

A free chat UI gives you a textbox and a model. The hard part — staying coherent across a long operation, picking the right tool from hundreds, remembering, routing, and proving every action — is a year of engineering. This is that part.

Routing & tuning in motion. Every turn hits the SmartModelRouter first — it sends the trivial work down to a cheap local model and escalates the hard work up to the frontier, and refuses rather than quietly under-delivering. You tune the thresholds; it does the rest.

Three-layer tool selection

Hundreds of tools, but the model only ever sees the relevant ≤15: intent routing → pgvector semantic search → a hard ceiling. Dumping the whole catalog at a model wrecks its accuracy — so we don't.

Context budget & compaction

The context window is partitioned across recent turns, summaries, and long-term knowledge — and long sessions compact silently at 65% and 85% instead of blowing the window and losing the thread.

Semantic memory

Per-user memory recalled from a vector layer with a context cache — not a flat scrollback. "What did we decide about that last week" resolves without a scrollback crawl.

SmartModelRouter

Five-step model resolution that routes down to a cheap local model for trivial turns and up to the frontier when a task demands it — and refuses rather than silently under-delivering.

Data & artifacts layer

An always-on data layer (query_data / list_datasets) and artifacts the agent produces and reuses — so a run builds on real, queryable state, not just text in a window.

Approval gate & signed audit

Every mutating tool call stops at a human-in-the-loop gate, then lands in an append-only, hash-chained, tamper-evident log. Free wrappers can't tell you who did what — this can.

See the architecture — every box maps to real code →

From a live local install

In production.

The agent calling live cloud tools, charting real metrics, reading images, and running fully on-box with Ollama. Click any capture to view it full size.

Real tools, real data

The agent calls the Azure cost tool as a service principal and renders a Sankey diagram of live subscription spend broken out by service
Azure cost, as a Sankey. The agent calls the Azure cost tool — running as a service principal — and renders live subscription spend, broken out by service.
The agent runs prometheus_query against a real monitoring stack and charts the returned up metric with a table of targets
Prometheus, queried + charted. prometheus_query hits a live monitoring stack; the agent turns the returned series into a chart.

Chat that does the work

OpenAgentic ChatMode answering a question about the platform in plain language, routed to the configured chat model
Chat on your model. ChatMode answering in plain language, on the model you configured.
The model reads an attached diagram and describes its boxes, labels and orange dots accurately
Vision reads the image. The model describes an attached diagram — boxes, labels and the orange dots — accurately.
A generated illustration of a friendly green robot mascot beside a server rack, rendered inline in the chat
Image generation, inline. A prompt for the green mascot and a server rack, generated and rendered right in the chat.

Runs on your stack

A fully local run on Ollama with a local Ollama model making native tool calls — no cloud provider in the loop
Fully local — Ollama, no cloud. a local Ollama model on your own Ollama making native tool calls — nothing leaves the box.
Docker logs showing nomic-embed-text embeddings served by local Ollama at 768 dimensions
Embeddings on-box (Ollama). nomic-embed-text vectors (768-dim) served by your local Ollama — straight from the container logs, $0 inference.

Platform shown at v1.0.0.

Mutating actions stop for a human; every call is written to a tamper-evident log — control before action, a record after.

Governance you own, from day zero

Self-hosted, gated on the writes, and all on the record.

OpenAgentic was engineered from day zero to the bar the most scrutinized environments set — built for the chain-of-custody and approval controls high-assurance environments demand, in from the start, not bolted on later. The open-source edition runs entirely inside your boundary.

  • Nothing leaves your boundary. Self-hosted on your own infrastructure — air-gapped if you want — with zero telemetry and no phone-home. The OSS edition runs on a local admin account; you point it at your own models and tools.
  • Human-in-the-loop on anything that mutates. Every write-class tool call stops at a server-side approval gate before it runs — the model investigates and recommends, a human decides.
  • A record you can verify. Every model call and tool use is written to an append-only, hash-chained audit log, so "what did the agent do, and who let it" always has a tamper-evident answer.

See the architecture →  ·  Per-user identity & SSO/OBO is Gnomus enterprise →

Run it your way

The full platform, in any browser.

OpenAgentic is a self-hosted web platform — chat, flows, and the admin console run in any modern browser, with nothing to install on your machine. Desktop coding apps and a mobile companion are AgenticWork products, separate from the open-source core.

  • Browser — the full open-source platform, served from your own deployment
  • Desktop — Gnomus Code for macOS & Windows (Gnomus, not part of OSS)
  • Mobile — a companion to drive flows and approvals (Gnomus, in the works)

Gnomus Code & the apps live at AgenticWork →

Mobile companion — in the works.

Get started

Up and running in five minutes.

Free to self-host, forever — you pay your model provider, no one else.

  1. 1Run one command
  2. 2The wizard sets up Docker or Kubernetes
  3. 3Point it at your model — you’re live
curl -sSL https://install.openagentics.io | bash

Enterprise

Or have us run it.

Fleet & Mission orchestration across many instances, managed hosting, and designed-for-FedRAMP-High governance.

[agenticwork]