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
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
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.
| Ops pain | How OpenOcta puts AI to work |
|---|---|
| Alert storms, hard root-cause | Aggregate alerts + correlate metrics / logs / changes; output root-cause hypotheses and remediation steps |
| Manual inspections, hard to retain results | Define inspection tasks in natural language; run on schedule and summarize risk lists |
| Data scattered across platforms | Intelligent data Q&A: query monitoring, logs, tickets, capacity, and cost in plain language |
| Too many tools, high switching cost | Skills / MCP / digital employees connect Zabbix, Prometheus, K8s, and more |
| Tribal knowledge, hard to reuse | Knowledge Vault retains Runbooks, cases, and personal remediation preferences |
| Night shifts, slow remote response | WeCom / DingTalk / Feishu / WeChat remote task dispatch |
🖥️ 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.
🎯 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):
| Category | Integrable / extendable examples |
|---|---|
| Monitoring & alerting | Zabbix, Prometheus, Grafana, Alertmanager, Nightingale |
| Logs & observability | ELK / OpenSearch, Loki, Graylog, cloud logging |
| Containers & orchestration | Kubernetes, Helm, Docker, container-cloud consoles |
| Automation | Ansible, Salt, script libraries, Cron / scheduled jobs |
| Databases | MySQL, PostgreSQL, Redis, MongoDB (slow queries / connections / backup checks) |
| Cloud & middleware | Public-cloud APIs, Nginx, Kafka, RabbitMQ, JVM / middleware health checks |
| Collaboration & tickets | WeCom / DingTalk / Feishu, Webhooks, CMDB / bastion hosts (per environment) |
👷 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).
🔧 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.
- 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.
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.
| OpenOcta | OpenClaw | Hermes | |
|---|---|---|---|
| Positioning | IT Ops Agent / AIOps Agent | General Gateway Agent | General CLI Agent |
| Install form | Windows / macOS double-click | CLI deploy | CLI deploy |
| Work scope | Full-stack IT ops (not limited to host OS) | General tasks | General tasks |
| Ops toolchain | Skills / MCP / digital employees (Zabbix, Prometheus, etc.) | General extensions | Skill self-generation |
| Runtime | Self-developed Go · single binary | Node.js | Python |
| IM channels | WeChat / WeCom / DingTalk / Feishu | Overseas IM lean | Overseas IM lean |
| Memory evolution | Four-tier memory + L4 Evolution | Workspace Markdown | Skill self-generation |
| Local knowledge base | Knowledge Vault (Runbook-friendly) | — | — |
| Time to start | ~30 seconds | Typically hours | Typically hours |
Full comparison & selection guide → docs/compare-openclaw-hermes.md
OpenOcta puts inspection, alerting, data Q&A, skills, and knowledge retention into one desktop client — so the ops loop is installable, connectable, and usable.
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
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
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
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
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
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.
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?”
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
- Download — GitHub Releases or the openocta.com download page
- Install & open — Double-click to install the desktop client (~30 seconds)
- 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)
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
| Platform | Config path |
|---|---|
| macOS | ~/.openocta/openocta.json |
| Windows | %APPDATA%\openocta\openocta.json |
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.
| Strongest IT Ops Agent (mission) | Focused on inspection, alert analysis, and intelligent data Q&A; covers application / server / network / desktop / DB / cloud |
| Desktop install ≠ host-only ops | Installed on Windows / macOS; work targets are your servers, clusters, cloud, and databases |
| Ops-toolchain friendly | Skills / MCP / digital employees connect Zabbix, Prometheus, K8s, DB, and common stacks |
| AI in the closed loop | Not empty chat: correlate context, give steps, call tools, and run scheduled on-call jobs |
| Self-developed Go runtime | Fully self-developed Gateway / Agent / Channels; single binary; no Node / Python in production |
| Local-first | Sessions and memory stay on-device — fit for enterprise ops compliance and intranet |
| IM remote command | WeCom / DingTalk / Feishu / WeChat — dispatch alerts and tasks anytime |
| Evolvable memory | Knowledge Vault + L4 Evolution — Runbooks and preferences keep accumulating |
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).
Visit the openocta.com download page:
| Platform | Package |
|---|---|
| Windows | OpenOcta-amd64-installer.exe |
| macOS (Apple Silicon) | OpenOcta-arm64.dmg |
| macOS (Intel) | OpenOcta-amd64.dmg |
| Platform | Default config directory |
|---|---|
| macOS | ~/.openocta/openocta.json |
| Windows | %APPDATA%\openocta\openocta.json |
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
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.
Ops users should prefer the installers above. The following is for secondary development / self-hosting.
- Go 1.24+ (backend build)
- Node ≥18 (frontend build only; not required in production)
ANTHROPIC_API_KEY(when using theagentCLI)
make build
./openocta gateway runGateway defaults to http://127.0.0.1:18900; the frontend is embedded via go:embed — open the Control UI directly in a browser.
./openocta gateway run # terminal 1
make run-ui # terminal 2 → http://localhost:5173export ANTHROPIC_API_KEY=your-key
./openocta agent -m "Hello, echo test"| Doc | Description |
|---|---|
| Architecture | Gateway, Agent, MCP, Skills |
| Configuration | agents, channels, gateway, cron, hooks, memory |
| Channels overview | IM / messaging channels |
| MCP configuration | MCP servers and permissions |
| Skills | Skills system |
| Tools | Built-in tools and extensions |
| Digital employees | Ops digital-employee mechanism |
| Webhooks | /hooks/wake, /hooks/agent |
| Comparison | OpenClaw / Hermes |
| Backend | Go modules |
| Frontend | Control UI |
| 简体中文 README | 简体中文 |
Upstream references: OpenClaw · docs.openclaw.ai
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/
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
This repository is licensed under Apache-2.0.