OpenOcta — ITOps AIAgent (AIOps Agent)

Mission: the strongest ITOps Agent
_{Windows / macOS desktop install · full-stack IT ops · natural-language inspection / alerting / data Q&A}

Website · Download · Skills Marketplace · Architecture · 简体中文

Keywords: IT Ops Agent · AIOps · Ops Agent · Alert Analysis · Auto Inspection · Intelligent Data Q&A · Zabbix · Prometheus · Kubernetes · SRE

One-line positioning

OpenOcta is a desktop IT Ops Agent for Windows / macOS: ops engineers install it locally with a double-click and assign work in natural language. The Agent connects your monitoring, logs, cloud platforms, databases, and script toolchains to run application / server / network / desktop / DB / cloud jobs across the stack — installed on Windows / Mac, not limited to operating only Windows / Mac.

The goal is not “yet another chatbot,” but AI inside a real ops loop: auto inspection → alert analysis → intelligent data Q&A → remediation advice / execution.

Latest v1.0.6 (2026-07-15) — Windows / macOS installers · fix empty tool-call argument errors · harden Windows write-file paths · Knowledge Vault UI redesign · single Go binary with embedded Control UI

All releases → · ⭐ Star the project

Why an Ops Agent, not a general-purpose Agent?

General Agents are strong at “writing docs, editing code, chatting.” Ops needs something that connects to live tooling, understands alert context, and closes the inspection & troubleshooting loop.

✨ Key features

Product form

🖥️ Desktop install, full-stack ops — Install on Windows / macOS; work targets cover Linux servers, containers, network devices, databases, cloud resources, and business apps — not just local-machine ops.

⚡️ Double-click ready (~30 seconds) — Full Control UI out of the box; no hours of CLI setup; built for frontline ops to get productive fast.

🪶 Ultra-lightweight — ~30MB-class installers, low memory footprint; suitable for 24/7 on-call residency.

🔒 Local-first — Sessions, memory, and ops context stay on your machine by default; intranet-ready; no Node / Python required in production.

Ops domain capabilities

🎯 Core IT ops scenarios out of the box — Auto inspection, alert analysis, intelligent data Q&A, release verification, slow-query analysis, capacity & cost triage — trigger with one sentence.

🔌 Common ops toolchain adapters — Connect popular stacks via Skills / MCP / digital employees (continuously expandable):

👷 Ops digital employees — One-click install role-based workers such as Zabbix SRE, Prometheus, and MySQL DBA — compose capabilities by scenario instead of assembling prompts from scratch.

📡 Alert intake & IM command — Dispatch tasks remotely via WeChat, WeCom, DingTalk, and Feishu; alerts can wake the Agent through Webhooks / channels.

🧠 Ops memory & evolution — Four-tier memory + L4 Evolution + Knowledge Vault: Runbooks, preferences, and historical cases stay local and get smarter over time (docs).

Engineering foundation

🔧 Fully self-developed Go runtime — Native Gateway, Agent, and Channels; single binary with embedded Control UI.

🧩 Extensible Skills & MCP — Built-in tools + MCP protocol + skills marketplace; keep adding capabilities for your enterprise stack.

Who is it for?

• Application / business ops & SRE: release verification, health checks, alert noise reduction, and root-cause analysis
• Infrastructure ops: hosts, networks, middleware, capacity, and inspection automation
• DBAs: slow queries, connection counts, backup and storage risk analysis
• Cloud ops / FinOps: resource triage, permission checks, cost anomaly analysis
• Desktop / endpoint ops: bulk environment checks, scripts, and remote-command assistance
• Teams that want AIOps to actually land: a desktop Agent you can install, connect, and put to work

Not a fit: scenarios that only want a generic chat window and never plan to connect any ops systems.

vs. OpenClaw & Hermes

OpenOcta is built around IT ops as the primary domain: desktop double-click install, full client UI, ops toolchain adapters, and China-local IM channels — putting AI into real inspection, alerting, and data-Q&A work. Versus OpenClaw (Node / self-hosted Gateway) and Hermes (Python / CLI-oriented), OpenOcta ships a self-developed Go single binary runtime with built-in L4 autonomous evolution and Knowledge Vault.

Full comparison & selection guide → docs/compare-openclaw-hermes.md

Feature gallery

OpenOcta puts inspection, alerting, data Q&A, skills, and knowledge retention into one desktop client — so the ops loop is installable, connectable, and usable.

Agent chat

Assign inspection, alert analysis, data Q&A, and remediation in natural language. The Agent correlates context and calls your ops toolchain.

Learn more: Scenarios · Architecture

Employee marketplace

One-click install role-based digital employees such as Zabbix SRE, Prometheus, and MySQL DBA — compose capabilities by scenario instead of assembling prompts from scratch.

Learn more: Digital employees · Built-in employees

Skills library

Enable 766+ Skills across monitoring, DevOps, and databases to connect your live stack, and keep extending via MCP.

Learn more: Skills · MCP configuration · Skills marketplace

Knowledge Vault

Retain Runbooks, standards, and historical cases for semantic retrieval — so the Agent learns your environment and remediation preferences over time.

Learn more: Knowledge Vault · User guide

Model configuration

Connect public or local models for intranet deployment and data-compliance needs. First launch can finish setup through the guided wizard.

Learn more: Model providers

Tutorials

Windows / Mac quick start and hands-on ops courses — so frontline teams can go from install to real work in about 30 seconds.

Learn more: Website · Start in 30 seconds

Also includes: Tools, scheduled inspection / Cron, IM channels, and Webhooks. More capabilities on openocta.com.

Typical ops scenarios

Core jobs (where AI amplifies value most)

Auto inspection — Periodically check hosts, services, middleware, and business availability; auto-summarize anomalies.
Example: “Inspect the production Web cluster and output availability plus disk / memory risk lists.”

Alert analysis — Aggregate alerts, correlate metrics / logs / changes, and provide root-cause hypotheses plus remediation advice.
Example: “Analyze this P1 alert and, with recent release history, give investigation steps.”

Intelligent data Q&A — Query monitoring, logs, tickets, and ops data in natural language; get conclusions in seconds.
Example: “Which top 5 APIs had the highest error rates in the past 24 hours?”

Coverage domains (desktop-installed, full-stack work)

Application ops — Release verification, health checks, log localization, rollback advice.
Example: “Verify tonight’s post-release health checks and list anomalous services.”

Server ops — Resources, processes, service status, and bulk inspection.
Example: “This Linux host’s CPU is spiking — find Top processes and suggest remediation.”

Network ops — Connectivity, pathing, proxy / DNS / certificate triage.
Example: “From the jump host, test connectivity to the DB segment and explain likely bottlenecks.”

Desktop ops — Endpoint environment, software status, and bulk script assistance.
Example: “Check whether this machine’s proxy and certificates are healthy, and give fix commands.”

DB ops — Slow queries, connection counts, backup and storage risk.
Example: “Check MySQL slow-query Top 10 and suggest optimizations.”

Cloud ops — Cloud resources, permissions, billing, and autoscaling triage.
Example: “List cloud resources with abnormal cost growth this week and explain likely causes.”

More cases: openocta.com/cases · scenario docs

Start in 30 seconds (Windows / macOS)

1. Download — GitHub Releases or the openocta.com download page
2. Install & open — Double-click to install the desktop client (~30 seconds)
3. Connect a model → start ops chat — Describe tasks in Messages; then install Zabbix / Prometheus Skills or digital employees as needed to connect your live toolchain

_{Product demo · Messages → Skills → Knowledge Vault → Ops Agent (to be added)}

First-time setup (~2 minutes)

After install, connect a large language model before chatting. Choose either path:

Option A — UI setup (recommended)
Open the client Models tab, or follow the first-run setup wizard, enter an API Key, and pick a model.

Option B — Edit the config file

Minimal example (Moonshot; for DeepSeek / Qwen / Doubao and more, see model provider docs):

{
  "env": {
    "vars": {
      "MOONSHOT_API_KEY": "sk-your-key"
    }
  },
  "agents": {
    "defaults": {
      "model": { "primary": "moonshot-cn/kimi-k2.5" }
    }
  }
}

Save, restart the client, and try this in Messages:

Design a daily inspection checklist for Web + MySQL, and explain how to trigger each item in natural language.

After connecting monitoring, try:

Pull the past hour’s error rate and 5xx from Prometheus / Zabbix, summarize anomalous services, and give an investigation order.

Why choose OpenOcta

Architecturally inspired by OpenClaw’s Gateway protocol and Control UI experience, fully self-developed in Go by the team, and positioned as an IT Ops Agent (AIOps Agent).

Download & install

Visit the openocta.com download page:

macOS: drag from the .dmg into Applications; see deploy/dist-README.md.

Online resources

• Website: https://openocta.com
• Skills / MCP / digital employee marketplace: https://resource.openocta.com
• Enterprise AMC: https://amc.openocta.com

FAQ

Q: What is OpenOcta?
A: OpenOcta is an open-source IT Ops Agent / AIOps Agent: install on Windows / macOS desktops and use natural language for inspection, alert analysis, intelligent data Q&A, and other ops jobs.

Q: Does it only operate Windows / Mac?
A: No. The client installs on Windows / Mac; work targets can be Linux servers, Kubernetes, databases, networks, cloud resources, and other full-stack IT assets.

Q: How is it different from ChatGPT / general Agents?
A: General Agents lean toward chat and office work; OpenOcta targets the ops closed loop — toolchain integration (Zabbix, Prometheus, etc.), digital employees, scheduled inspection, IM on-call, and local knowledge retention.

Q: Which ops systems can it connect to?
A: Extend via Skills, MCP, and digital employees; common ones include Zabbix, Prometheus, Grafana, Kubernetes, MySQL/PostgreSQL, Ansible, ELK/Loki, and cloud APIs — keep adding for your environment.

Q: Is data uploaded?
A: Local-first by default: sessions and memory stay on your machine; model calls depend on the public / local models and network policy you configure; intranet deployment is supported.

Q: How do individuals and teams use it?
A: Individuals install the client directly; teams can standardize capabilities via the skills marketplace; for enterprise scenarios, see AMC.

Developers: run from source

Ops users should prefer the installers above. The following is for secondary development / self-hosting.

Requirements

• Go 1.24+ (backend build)
• Node ≥18 (frontend build only; not required in production)
• ANTHROPIC_API_KEY (when using the agent CLI)

Build & start

make build
./openocta gateway run

Gateway defaults to http://127.0.0.1:18900; the frontend is embedded via go:embed — open the Control UI directly in a browser.

Dev mode

./openocta gateway run    # terminal 1
make run-ui               # terminal 2 → http://localhost:5173

Agent CLI

export ANTHROPIC_API_KEY=your-key
./openocta agent -m "Hello, echo test"

Documentation

Upstream references: OpenClaw · docs.openclaw.ai

Project structure

OpenOcta/
├── src/                    # Go backend (Gateway, Agent, Channels, Cron)
├── ui/                     # Control UI (Lit + Vite)
├── deploy/                 # Installers, Docker, systemd
├── docs/                   # Documentation
└── imgs/                   # Logo, screenshots, community QR
    ├── readmePIC/
    └── screenshots/

Contributing

If you are building AIOps / intelligent ops, join us in making “the strongest IT Ops Agent” a real, usable open-source foundation:

• ⭐ Star this repo and Watch for updates
• 🐛 File ops-scenario Issues (alerts, inspection, and toolchain integration are most valuable)
• 🔧 Good first issues
• 🤝 Read CONTRIBUTING.md and open a PR
• 💬 Scan the QR or visit openocta.com

_{Scan to join the OpenOcta discussion group · ops scenario co-building and support}

License

This repository is licensed under Apache-2.0.