Agent-first command tree
From connections and datasets to HQL, dashboards, elements, and authorization, one command surface covers the main BI engineering chain.
Execution layer
Let AI agents execute BI engineering from the terminal
HENGSHI CLI turns data access, HQL queries, dashboard generation, permissions, and delivery operations into a tool surface agents can call directly, together with bundled skills split by command domain. Whether the runtime is a coding agent like Claude Code or Codex, or a persistent agent like OpenClaw or Hermes Agent, the workflow moves from "telling people where to click" to "executing the work for you."
Bundled skills
The repo ships with a skills directory that turns data, modeling, dashboarding, permissions, and orchestration into reusable runbooks for agents.
Engineering-grade security
Tokens stay in the system keyring with OAuth and enterprise SSO support, instead of leaking into local config files.
Structured output
Native JSON, YAML, and table output reduces the prompt and context budget agents would otherwise spend on parsing.
From context discovery to asset generation, the agent no longer has to stitch together loose APIs or invent its own BI runbook.
$ everest auth status --output json
{ "status": "authenticated", "provider": "oauth" }
$ everest dataset list --app retail-ops --output json
[{ "id": "sales_daily", "metrics": 12, "dimensions": 8 }]
$ everest dashboard create --app retail-ops "East China command center"
Created dashboard dsh_2048
$ everest element chart create --dashboard dsh_2048 --app retail-ops --dataset sales_daily line
Created element chart_17
JSONDashboardHQLAgent-ready
Before permissions, deployment, or migration steps enter automation, both the agent and a human get a reviewable preview surface first.
$ everest authorize grant --target-type app --target-id app_42 --user 123:editor --dry-run
Dry run passed · changes not applied
Preview: editor access -> retail-ops
--dry-runAuthorizeAudit trail
Results are not trapped in the terminal. The web interface can reflect agent changes in real time for review.
# agent updates dashboard filters from a spec file
$ everest element filter update filter_9 --dashboard dsh_2048 --app retail-ops --file filter.yaml
SSE broadcast published
Web UI refreshed · business owner can review instantly
SSEWeb UIHuman-in-the-loop
Bundled agent skills
Give the agent both the command surface and the skills bundle for stable execution
HENGSHI CLI does not ship only a binary. It also ships the skills directory that predefines command entry points, help discovery order, dry-run checkpoints, and cross-domain transitions. That lets both coding agents and persistent runtimes reuse the same BI runbook.
Split complexity by resource domain
App, data, dashboard, permission, and workflow domains become stable skills instead of one overstuffed mega-prompt.
Help-first protocol
Skills begin with everest --help and subcommand help before execution, reducing parameter guesswork.
Reusable across agent styles
Claude Code, Codex, OpenClaw, Hermes Agent, and CI pipelines can all reuse the same execution boundaries.
The CLI repo ships with 9 skills so domain boundaries, representative commands, and execution order are already stabilized for agents.
# bundled with the CLI repo
everest-core auth / config / output / terminology
everest-data connection -> dataset -> metric / measure
hql-expert business ask -> HE / HQL expression
everest-dashboard plan scaffold -> validate -> apply
everest-workflow sequence cross-domain steps and checkpoints
agent follows domain boundaries instead of guessing commands
9 skillsHelp-firstDry-runDomain-aware
Foundation
Unify terminology, auth, and output rules first
everest-core narrows auth, config, search, output, and terminology boundaries before the agent starts guessing flag names or resource scope.
everest auth statuseverest search --output json Data & HQL
Split access, modeling, and formulas into dedicated domains
everest-data, everest-data-modeling, and hql-expert focus separately on connections and datasets, join decisions, and HE/HQL expression generation.
everest dataset list --app <id>everest data-model query "SUM({amount})" Build
Application and dashboard delivery get their own runbooks
everest-app and everest-dashboard cover analytic apps, Dashboard Plan, elements, and YAML batch layout so delivery details do not get stuffed into one giant prompt.
everest dashboard plan apply --file plan.yamleverest app publish <app_id> Govern
Permissions, users, and orchestration stop getting mixed together
everest-permission, everest-user-mgmt, and everest-workflow handle dry-run checks, authorization, user governance, and cross-domain sequencing.
everest authorize grant --dry-runeverest user-group list Agent workflow
Not a chat wrapper, but an executable BI engineering interface
The value of HENGSHI CLI is that agents read context first, execute next, and hand the result back for human review. The whole chain works like an engineering interface reusable through skills and runbooks, not like scattered click-memory.
01
Read the analytics context before acting
The agent should first understand the app, dataset, semantic layer, and asset state so the next step does not become a blind mutation.
$ everest connection list
$ everest dataset list --app retail-ops
$ everest data-model query --app retail-ops --dataset sales_daily "SUM({amount})"
result: 24510931
ConnectionDatasetHQL
02
Generate deliverable assets, not just answers
Once context is confirmed, the CLI stops being a chat helper and actually creates dashboards, themes, elements, and layouts that teams can ship.
$ everest dashboard create --app retail-ops "Sales command center"
$ everest dashboard theme show CLASSIC --as-spec --output yaml
$ everest element container create --dashboard dsh_2048 --app retail-ops --file layout.yaml
Container + chart scaffolding ready
DashboardThemeElement
03
Keep security, permissions, and delivery in one chain
Enterprise BI engineering does not end at "created successfully". Permissions, auditability, migration, and human approval still need to be part of the same executable flow.
$ everest authorize get --target-type app --target-id app_42
$ everest user-group list
$ everest authorize grant --target-type app --target-id app_42 --user 123:editor --dry-run
Ready for pipeline approval
AuthorizeUserCI-ready
Agent runtime
Built for agents that can call tools, not one specific shell
Today the obvious categories are coding agents like Claude Code and Codex, and persistent agents like OpenClaw and Hermes Agent. The more important point is future compatibility: as long as the next generation can call shell tools, HENGSHI CLI can remain their BI execution layer.
Shell-tool compatible
Fits local terminals, IDE agents, persistent services, and automation pipelines.
Skill-friendly
Works naturally with skills, template repos, runbooks, and approval workflows.
Human review built in
Dry-run previews, structured output, and SSE feedback keep automation inspectable.
Claude Code / Codex
Best for complex delivery work that stays close to a repository, shell, and spec files.
When the agent works inside a local repo or CI environment, HENGSHI CLI can turn data preparation, dashboard planning, and permission changes into one reviewable command chain.
In-repo implementation, script generation, CI/CD integration
OpenClaw / Hermes Agent
Best for persistent runtimes that live in cloud services, chat channels, or long-running automation surfaces.
These runtimes behave like an always-on execution layer: they can accept natural-language requests, keep context across sessions, and keep calling HENGSHI CLI as a stable BI tool surface.
Persistent assistants, message channels, cloud automation
Many more agents ahead
The current list is only a snapshot. Better and stronger agent runtimes will keep appearing.
The stable thing is not one shell wrapper but the shell / tool-calling interface itself. As long as the next generation of agents can call tools, HENGSHI CLI can remain their BI execution layer.
Future coding agents, persistent agents, and orchestration runtimes
Further reading
Go deeper with the existing HENGSHI CLI technical articles
HENGSHI CLI debuts as a Rust-based execution layer for Agentic BI
Why BI in the agent era should not stop at a chat shell, and why a real terminal execution layer matters.
Why HENGSHI CLI goes beyond APIs for agent-driven BI automation
A focused walkthrough of command unification, structured output, secure credential handling, and why the execution model fits agents better than API stitching.
How HENGSHI CLI supports end-to-end BI engineering delivery
A scenario-driven view of implementation, operations, permissions, and cross-environment handoff with HENGSHI CLI.