🎯 What Makes HippoX Different?

• 🗣️ Natural Language Interface — Talk to HippoX like you’d talk to a human. Say “check disk space” or “send an email report” — it just works
• 📝 SKILL.md Workflows — Write reusable, shareable skills as markdown files. Define parameters, instructions, and triggers — HippoX auto-loads them
• 🔄 Dual Input Modes — Same engine, same skills. Whether you type a command or invoke a SKILL.md file, the execution is seamless
• 🤖 Autonomous Decision — LLM-powered skill selection and execution, fully autonomous
• 🔌 100+ Atomic Skills — File system, network, database, Docker, k8s, GitHub, and more
• ⚡ 4 Workflow Modes — ReAct, Batch, Chain, PlanAndExecute for any use case
• 🌍 Multi-Language Support — English, Chinese, and more coming soon
• 🔧 Highly Configurable — Environment variables, TOML, JSON config support

Two ways, one engine:

🚀 Quick Start

Installation: Add hippox to your Cargo.toml dependencies, or clone from GitHub and build from source.

Minimal Setup: Initialize HippoX with your skills directory and LLM provider (OpenAI, Anthropic, or local Ollama). Then start processing natural language commands or execute SKILL.md workflows.

First Skill: Create a directory with a SKILL.md file containing YAML frontmatter and markdown instructions. HippoX auto-loads it instantly.

🚀 Core Architecture

The core engine supports four task flow modes, each optimized for different scenarios:

🔄 ReAct Mode (Think → Act → Observe)

How it works: The LLM thinks about the task, executes a skill, observes the result, then decides the next action. This loop continues until the task is complete.

Best for: Open-ended tasks, dynamic decision making, error recovery, multi-step reasoning

Example scenario: “Find the largest file in my downloads folder, compress it if it’s over 100MB, then move it to archive”

The LLM will:

1. First list files in downloads folder
2. Identify the largest file and check its size
3. Decide whether compression is needed
4. Execute compression if condition met
5. Move the file to archive folder
6. Report back the result

LLM calls: One per skill execution, plus one final response

⚡ Batch Mode (Parallel Execution)

How it works: Multiple independent skills are executed simultaneously with no dependencies between them.

Best for: Independent operations, bulk processing, parallel data collection

Example scenario: “Get my current CPU usage, memory usage, disk space, and network status”

All four checks run at the same time and results are aggregated once all complete.

LLM calls: One (generates batch plan)

⛓️ Chain Mode (Sequential with Variable Passing)

How it works: Skills execute one after another. Each skill’s output can be passed as input to the next skill using {{variable}} syntax.

Best for: Linear pipelines, data transformation chains, ordered processing

Example scenario: “Read data from sales.csv, calculate the average sales amount, then write the result to summary.txt”

The flow:

• Step 1 reads CSV and output is stored as sales_data
• Step 2 calculates average from {{sales_data}} and stores as avg_result
• Step 3 writes {{avg_result}} to summary.txt

LLM calls: One (generates chain plan)

📋 PlanAndExecute Mode (Conditional Workflows)

How it works: A complete execution plan is generated upfront, supporting conditional branching, variable references, and error handling strategies.

Best for: Complex workflows, conditional logic, production deployments, tasks requiring retry logic

Example scenario: “Check disk space. If below 10%, send alert email and clean up temp files. Otherwise, proceed with backup.”

The plan includes:

• Step 1: Check disk usage
• Step 2 (condition): Send alert if usage < 10%
• Step 3 (condition): Clean temp files if usage < 10%
• Step 4: Proceed with backup (only if disk space is sufficient)

Error handling options:

• Retry — Automatically retry failed steps up to N times
• Skip — Skip failed step and continue
• Fail — Stop execution and report error

LLM calls: One plan generation + optional for dynamic decisions

📊 Workflow Modes

📦 Atomic Skills Overview

Total: 150+ built-in skills and growing!

💡 Real-World Use Cases

📁 Automated File Processing

Let HippoX monitor a directory, automatically compress old files, archive them by date, and generate summary reports — all through natural language instructions.

🌐 Intelligent Network Monitoring

Deploy HippoX to periodically ping servers, check API health, perform DNS lookups, and send alerts via Telegram or email when issues are detected.

🗄️ Database Operations

Ask HippoX to query your PostgreSQL database, analyze MySQL tables, manage Redis caches, or generate SQLite reports — just by describing what you need.

☸️ DevOps Automation

Control your Kubernetes cluster through natural language: scale deployments, restart pods, fetch logs, apply YAML manifests, or forward ports — without memorizing kubectl commands.

🐳 Docker Management

Manage containers with simple requests: list running containers, start or stop services, inspect container details, execute commands inside containers, or tail logs.

🐙 GitHub Integration

Automate repository management: create issues, list pull requests, star repos, search code, get user profiles — all through conversational AI.

📄 Document Processing

Parse CSV files, read Excel spreadsheets, extract text from PDFs, convert XML to JSON, or generate Markdown documentation — HippoX handles it all.

💬 Multi-Platform Messaging

Send notifications across multiple platforms (Email, Telegram, DingTalk, Feishu, WeCom) from a single unified interface.

🔌 Supported Integrations

• Cloud LLMs: OpenAI, Anthropic, DeepSeek
• Local LLMs: Ollama, LocalAI
• Databases: PostgreSQL, MySQL, Redis, SQLite
• Containers: Docker, Kubernetes
• Version Control: GitHub
• Messaging: SMTP, Telegram, DingTalk, Feishu, WeCom
• File Formats: CSV, Excel, PDF, Markdown, XML, JSON
• Network: HTTP, TCP, UDP, FTP, DNS, ICMP

📈 Project Statistics

• 150+ Built-in atomic skills
• 4 Workflow modes
• 18 Skill categories
• Rust 1.70+ required
• Apache 2.0 License
• Active development

🌟 Who Is Using HippoX?

• AI Agents — Build autonomous agents with tool-calling capabilities
• DevOps Teams — Automate infrastructure management
• Data Engineers — Process and transform data pipelines
• Rust Developers — Leverage type-safe skill execution
• Open Source Contributors — Extend with custom SKILL.md files

🤝 Contributing

We welcome contributions! You can:

• Add new atomic skills
• Improve documentation
• Report bugs or suggest features
• Write custom SKILL.md files
• Translate to more languages