The 15 Levels of Hermes Agent Usage

Overview

Most people install Hermes Agent and use it as a chatbot. They type a prompt, get a response, close the tab. That covers maybe 10% of what the agent can do.

This guide maps every level of Hermes Agent usage, from the first prompt to a system that runs your business without you — 15 levels, grouped into three phases. Each level builds on the one before it, but you can jump to any level that fits your setup. For every level you get: what it is, what it unlocks, how to set it up, and the mistake that trips people up at that stage.

All technical details are verified against Hermes Agent v0.17.0 official documentation and source code.

Phase 1 — Foundation (Levels 1-3)

You are using Hermes. The agent responds to what you ask.

Level 1 — One-Shot Prompts

What it is: You installed Hermes. You type prompts. The agent responds with tool calls, file edits, web searches, and terminal commands. Basic interaction.

What it unlocks: Hermes executes tasks across your file system, terminal, and the web. It reads files, writes code, searches the internet, runs shell commands. It does things — a chatbot only talks about them.

Setup:

• Desktop app: download from hermes-agent.nousresearch.com. One-click install.
• CLI: hermes setup

Three setup modes:

• Quick Setup (Nous Portal): OAuth login, model + Tool Gateway in one command.
• Full Setup: walk through every provider, tool, and option yourself.
• Blank Slate: everything starts OFF except provider, model, file tools, and terminal. No web search, no browser, no memory, no delegation, no cron, no skills, no plugins, no MCP. You enable only what you need. Nothing loads that you didn't choose, even after updates.

Blank Slate is the cleanest starting point for users who want full control over what the agent can and cannot do. Connect a model provider, then start chatting.

The mistake: Treating Hermes as a search engine. "Tell me about X" wastes an agent that can DO things. "Research X, write a report, save it to ~/reports/" uses the tools.

Example: research the top 5 CRMs for solo founders, compare pricing and features, save a report to ~/reports/crm-comparison.html — the agent searches, compares, and writes the file. Done in 3 minutes.

Level 2 — Memory + SOUL.md

What it is: Hermes remembers you across sessions. SOUL.md defines who the agent is. MEMORY.md and USER.md store durable facts about your projects, preferences, and business context.

What it unlocks: The agent stops asking you to re-explain things. Two people asking the same question get different answers because Hermes knows their different contexts. Your instructions, preferences, and business details persist across every session.

v0.17.0 added atomic memory operations: the agent can batch add, replace, and remove memory entries in one call. Memory updates no longer fail mid-edit when the budget is tight.

Setup:

• Desktop app / Dashboard: Profile → SOUL.md → edit
• CLI: open ~/.hermes/SOUL.md in any editor

Write 50-80 lines covering identity, voice, operations, and restrictions. The agent reads this on every session start.

The mistake: Leaving SOUL.md empty and expecting personalized output. Hermes without a SOUL.md is generic by design. The identity file is the difference between a general assistant and YOUR assistant.

Example: you ask "should I raise prices?" Without SOUL.md: generic pricing-strategy advice. With a SOUL.md containing your business model, margins, and customer segments: "your entry tier converts at 12%. raising it $10 risks churn in segment B where you have 60% of revenue. test on segment A first."

Level 3 — Slash Commands

What it is: Commands that change how the agent works mid-session. Most users never type these.

What it unlocks: Parallel work inside a single session. You stop waiting for one task to finish before starting the next.

The commands:

• /background <prompt> — fires a task in the background. Your main session stays free. Result appears as a panel when done.
• /steer <prompt> — injects a message into the current run without interrupting it. Redirects the agent mid-execution.
• /queue <prompt> — queues a follow-up. Waits until the current task finishes, then runs automatically.
• /model <name> — switches models mid-session. Start with Sonnet for planning, switch to DeepSeek for execution, switch to Opus for review.

v0.17.0 added grok-composer-2.5-fast via Grok OAuth: the 200K-context coding model behind Cursor's Composer, accessible through your Grok subscription.

Configure default behavior when you type while the agent is busy:

# Desktop app, Dashboard, or config.yaml
display:
  busy_input_mode: steer  # or queue, or interrupt

The mistake: Not knowing these exist. Most users type a prompt, wait for it to finish, then type another. /background alone doubles your throughput per session.

Example: you're drafting a proposal. Mid-session: /background research [competitor] pricing and positioning. You keep writing. Five minutes later a panel appears with the competitive analysis. You paste it into the proposal without breaking flow.

Phase 2 — Leverage (Levels 4-7)

Hermes works smarter. You stop doing tasks the agent can handle.

Level 4 — Skills + Right Model Per Skill

What it is: Skills are on-demand knowledge documents and tool collections the agent loads when needed. Each skill can run on a different model.

What it unlocks: The agent becomes a specialist on demand. A research skill loads research methodology. A code-review skill loads security patterns. Each skill uses the model best suited for its job.

Setup:

• Desktop app / Dashboard: Skills Hub → Browse → Install
• CLI: /skills search [topic]

v0.17.0 rehauled the Skills Hub: connected hubs (OpenAI, Anthropic, HuggingFace, NVIDIA), a featured section, full skill previews before install, and a security scan on each skill. It also added image editing: image_generate now edits source images ("make this logo blue", "remove the background") — same tool, new mode.

Assign a model per skill in the Desktop app or config.yaml:

• research / web search → DeepSeek V4 Flash ($0.10/M tokens, cheapest)
• code review → Claude Opus 4.8 ($5/$25/M, best coding benchmarks)
• content writing → Claude Sonnet 4.6 ($3/$15/M, strongest prose + tool calling)
• coding (value) → GPT-5.5 ($2/$12/M, #1 Chatbot Arena, 2M context)
• research with grounding → Gemini 2.5 Pro ($1.25/$10/M, Google Search built in)
• bulk sub-agent work → DeepSeek V4 ($0.30/$0.50/M, 90% cache discount)
• /goal judge → Gemini Flash (cheapest, fast enough for binary done/not-done)
• self-hosted (free) → Qwen 3 8B via Ollama (8GB RAM, handles routine tasks)

MiniMax M2.7 is also worth testing — Nous Research and MiniMax are collaborating to optimize future releases for Hermes, and it's one of the most-used models inside Hermes as of mid-2026.

The mistake: Running every skill on your most expensive model. A routine web-search skill burning Opus tokens is money wasted. Match model cost to task complexity.

Example: you run a competitive-research skill on DeepSeek V4 Flash instead of Opus 4.8. Comparable quality for web search, 30-50x cheaper per call. Over 30 runs a month the savings add up fast.

Level 5 — MCPs (Connect Your World)

What it is: MCP (Model Context Protocol) servers connect Hermes to external tools: Gmail, Calendar, Notion, Slack, ClickUp, GitHub, databases, APIs.

What it unlocks: The agent works with YOUR data, not just the open web. It reads your emails, checks your calendar, pulls from your project board, and answers questions using context from the tools you already use.

Setup:

• Desktop app / Dashboard: MCP → Catalog → browse and install
• CLI: hermes mcp

The mistake: Connecting 15 MCPs at once. Every MCP adds tool schemas to the context window. 15 MCPs with 10 tools each = 150 tool definitions the model reads every turn. Install what you use, disable what you don't. Tool Search (auto-enabled when schemas eat 10%+ of context) helps manage this, but fewer MCPs is still better.

Example: "what happened in Slack this week while I was heads-down coding?" The agent reads your Slack channels, filters by mentions and key topics, cross-references with your goals in memory, and delivers a 10-line summary. No tab switching, no scrolling through 200 messages.

Level 6 — Sub-Agents + Parallel Execution

What it is: delegate_task spawns isolated sub-agents with their own context window, terminal session, and toolset.

What it unlocks: Parallel work across multiple agents. One researches, one critiques, one codes, and the parent orchestrates. Each child can run a different model.

Setup: the agent uses delegate_task automatically when a task benefits from isolation. You can also ask directly:

"spin up a sub-agent on DeepSeek to research X while another on GPT-5.5 critiques the findings"

# Desktop app, Dashboard, or config.yaml
delegation:
  max_concurrent_children: 3    # default
  max_spawn_depth: 2            # bounds recursion

Roles:

• leaf (default): executes, cannot re-delegate
• orchestrator: can spawn its own workers

Background mode (v0.17.0): delegate_task(background=true) dispatches the sub-agent and returns immediately. Your session stays live; the result re-enters as a new turn when it finishes.

The mistake: Using sub-agents for simple tasks. Delegation has overhead (context setup, tool allocation). A task the main agent can handle in 3 turns should not spawn a sub-agent.

Example: "research three competitors in parallel — one agent per competitor on DeepSeek, parent on Sonnet synthesizes." Three reports in 10 minutes instead of 30. Each agent works isolated, so one slow research task doesn't block the others.

Level 7 — Async Operations

What it is: Three features that let Hermes work without you typing.

What it unlocks: The shift from "I ask, it responds" to "it works, I review."

/goal — persistent objectives: set a goal. A judge model evaluates after every turn: done or not done? The agent continues automatically until the goal is achieved, you pause it, or the turn budget (default 20) runs out.

/goal find 100 clinics in Toronto,
build a landing page for each,
draft personalized emails to each clinic.

/subgoal adds criteria mid-run without resetting the loop.

Cron jobs — scheduled tasks: the Gateway ticks every 60 seconds, firing due jobs in fresh isolated sessions and delivering results to 27+ platforms: Telegram, Discord, Slack, WhatsApp, Signal, Matrix, iMessage, Microsoft Teams, Google Chat, LINE, email, SMS, and more.

v0.17.0 additions:

• WhatsApp Business Cloud API (official Meta adapter, no QR bridge)
• iMessage via Photon Spectrum (no Mac relay needed)
• Telegram rich messages (Bot API 10.1, native formatting)
• Automation Blueprints: one-click cron templates in the Dashboard (morning briefing, weekly review, news digest, reminder) — no cron syntax needed.

Three cost layers:

• no_agent mode: the script IS the job, $0 forever
• wakeAgent gate: the script decides if an LLM is needed, $0 until something changes
• context_from: chain job outputs into pipelines without a framework

Safety net — checkpoints: enable checkpoints before running autonomous operations. The agent snapshots your working directory before changes; /rollback restores state if something goes wrong overnight.

# Desktop app, Dashboard, or config.yaml
checkpoints:
  enabled: true

The mistake: Writing vague cron prompts. Every cron run starts from zero — no memory, no chat history. "Check on that server issue" means nothing. "SSH into 10.0.0.5, check nginx status, verify port 443 returns 200" works.

Example: 8:00 AM, Telegram pings. You didn't ask for this — cron delivered it: "3 new arXiv papers in your niche. competitor updated their pricing page. GitHub repo you watch merged a breaking change. action: review competitor pricing before your 11am call."

Phase 3 — Autonomy (Levels 8-15)

Hermes works without you. The system compounds over time.

Level 8 — Multi-Profile Architecture

What it is: Separate Hermes profiles, each with its own SOUL.md, config, memory, skills, cron jobs, and model. Fully isolated agents on one machine.

What it unlocks: Specialized workers instead of one overloaded generalist. A Scout profile finds signals, an Analyst synthesizes research, a Coder ships features. Each does one job well with the right model for that job.

Setup:

• Desktop app / Dashboard: Profiles → Build (5-step wizard: Identity → Model → Skills → MCPs → Review)
• CLI: hermes profile create [name]

Each profile becomes its own command:

hermes -p scout chat
hermes -p analyst chat

The mistake: Giving every profile the same SOUL.md. The entire point is isolation. A Scout that tries to analyze wastes tokens; an Analyst that tries to find sources duplicates Scout's work. One job per profile.

Example: Scout found 12 sources overnight. Analyst synthesized them into 4 wiki entries by 10am. Briefer delivered a 5-bullet summary at 8am. You read it over coffee. None of them share memory — each did one job with the right model.

Level 9 — Self-Improving Knowledge Base

What it is: The LLM Wiki skill, based on Andrej Karpathy's pattern — a self-improving knowledge base built as interlinked markdown files. Ships bundled with Hermes.

What it unlocks: Long-term knowledge that compounds beyond the memory cap. Hermes's built-in memory handles conversational context; the wiki handles domain knowledge — articles, transcripts, meeting notes, research findings. Cross-references stay linked and contradictions get flagged automatically.

Setup:

# Desktop app, Dashboard, or config.yaml
WIKI_PATH=~/obsidian-wiki

On first run, the skill asks for your domain to build SCHEMA.md with the right tag taxonomy. Connect to Obsidian for graph view by setting OBSIDIAN_VAULT_PATH to the same directory. Feed it: "index this article into my wiki: [paste URL or text]".

The mistake: Never feeding the wiki. An empty knowledge base adds nothing — the value comes from accumulation. Month 1: 50 entries. Month 3: 300+ entries with cross-references. The agent gets sharper because the knowledge base got sharper.

Example: you ask "how does competitor X handle onboarding?" Without a wiki: generic web results. With 3 months of wiki entries: the agent pulls your own research notes, a meeting transcript where a client mentioned competitor X, and an article you indexed last month — context no web search could find.

Level 10 — Kanban Orchestration

What it is: A durable SQLite task board shared across all profiles. Statuses flow triage → todo → ready → running → blocked → done → archived. A dispatcher fires every 60 seconds.

What it unlocks: Complex multi-step projects with dependency chains. Each card can run its own /goal loop (goal_mode). Cards with unfinished parent cards wait automatically. Multiple profiles pick up cards assigned to them.

Setup:

/kanban create "Research 100 clinics" \
  --assignee scout --goal --goal-max-turns 15

/kanban create "Build landing pages" \
  --assignee coder --goal --goal-max-turns 20 \
  --depends-on "Research 100 clinics"

CLI: hermes kanban, or /kanban in chat.

Kanban vs cron vs delegate_task:

• Kanban: durable work queue, persists across restarts, multi-profile
• Cron: time-based scheduling, repeating tasks
• delegate_task: one-off parallel execution within a session

The mistake: Using Kanban for simple linear pipelines. Three profiles in a straight line (Scout → Analyst → Briefer) work fine with file-based coordination. Kanban adds value when you have dependency trees, parallel branches, or 10+ tasks that need tracking.

Example: quarterly competitive analysis as a Kanban project — 12 cards (3 competitors × 4 dimensions: pricing, features, positioning, hiring signals). The pricing card depends on a web-scraping card; the hiring card depends on a LinkedIn-research card. Agents pick up work as dependencies clear. You review the final synthesized report.

Level 11 — Voice Mode

What it is: Speech-to-text and text-to-speech across all messaging platforms. Six STT providers, five TTS providers.

What it unlocks: Talk to Hermes through voice messages on Telegram, Discord, WhatsApp. The agent transcribes, processes, and can respond with synthesized speech — full voice conversations without typing.

STT providers: faster-whisper (free, on-device), local command wrapper, Groq (fast cloud), OpenAI Whisper API, Mistral, xAI.

TTS providers: Edge TTS (free, default), ElevenLabs (best quality, paid), OpenAI TTS, MiniMax, NeuTTS (free).

The mistake: Using expensive cloud STT for routine voice messages. Local faster-whisper handles most languages well and costs nothing. Save paid STT for complex audio or noisy environments.

Example: driving to a meeting. Voice message on Telegram: "anything from last night's research I should know before my 11am call?" The agent responds with a 30-second audio summary. You listen instead of read. Hands on the wheel.

Level 12 — Browser Automation

What it is: Hermes can control a browser to navigate websites, fill forms, extract data, and interact with web applications.

What it unlocks: Tasks that require a browser session — scraping dynamic pages, filling web forms, interacting with tools that have no API. The agent sees the page and acts on it.

Setup: included in Tool Gateway for Nous Portal subscribers:

hermes setup --portal

Or configure browser automation separately through the dashboard.

The mistake: Using browser automation for tasks that have an API. Browser automation is slower, more fragile, and more expensive than a direct API call. Use it only when no API exists.

Example: competitor has no public API. The agent opens their pricing page via browser, extracts current plans and pricing, and compares against last month's snapshot stored in your wiki. Change detected: they dropped their free tier. Flagged in your morning brief.

Level 13 — API Server

What it is: Hermes exposed as an OpenAI-compatible HTTP endpoint. Full agent with tools, memory, and skills accessible via standard API format.

What it unlocks: Any frontend that speaks OpenAI format connects to Hermes as a backend — Open WebUI, LobeChat, LibreChat, ChatBox, custom applications, Excel integrations. The agent becomes an API you build on top of.

Setup:

# Desktop app, Dashboard, or .env
API_SERVER_ENABLED=true
API_SERVER_KEY=your_secret_key

Start the gateway — Desktop app / Dashboard: Gateway → Start, or CLI: hermes gateway.

Endpoint: http://127.0.0.1:8642/v1/chat/completions

Multi-user setup: create one profile per user on different ports. Each gets isolated config, memory, and skills.

The mistake: Exposing the API server to the public internet without authentication. The server binds to 127.0.0.1 by default — access remotely via SSH tunnel, not public exposure. v0.17.0 added an OAuth gate on every token-required endpoint and websocket auth for the dashboard.

Example: your competitive research runs as an API endpoint. A custom dashboard queries Hermes for the latest intel. Your team sees competitive data on a live internal page — nobody opens Telegram, the data serves itself.

Level 14 — IDE Integration (ACP)

What it is: Hermes runs as an ACP (Agent Communication Protocol) server inside VS Code, Zed, and JetBrains editors.

What it unlocks: Chat, tool activity, file diffs, and terminal commands render inside your editor. The agent works in your project directory with your editor's context — same agent core, same tools, same memory as CLI and gateway.

Setup:

hermes acp start

In VS Code: install the ACP extension and point it to Hermes.

ACP includes: file tools (read_file, write_file, patch, search_files), terminal execution, a chat interface inside the editor, and approval prompts for dangerous commands.

ACP excludes (by design): messaging delivery, cron job management, gateway-specific features.

The mistake: Thinking ACP replaces the gateway. ACP is for coding sessions inside an editor; the gateway handles messaging, cron, and multi-platform delivery. Both run the same agent core underneath.

Example: coding a pricing page. Inside VS Code you ask Hermes: "how does competitor X structure their tiers?" The agent checks your Obsidian wiki, finds your research notes, and answers. You adjust your design without opening a browser or Telegram.

Level 15 — Profile Distributions

What it is: Package your entire agent setup as a git repo. Anyone installs your agent with one command.

What it unlocks: Your agent becomes a product. Sell it, share it with your team, distribute it to clients. Everything transfers except API keys and personal memories.

v0.17.0 also introduced the RAFT Agent Network: connect Hermes to raft.build as an external agent. A wake-channel bridge with privacy by contract (wake payloads carry metadata only, never message bodies). Your agent can collaborate with agents on other machines.

What a distribution contains:

distribution.yaml    # manifest
SOUL.md              # identity
config.yaml          # model and provider settings
skills/              # custom skills
cron/                # scheduled jobs
mcp.json             # connected tools

Install someone else's distribution:

hermes profile install github.com/user/their-agent

The mistake: Including API keys or personal data in the distribution. Credentials stay per-machine. The distribution carries personality, skills, and workflows; the user brings their own keys.

Example: you built a research department with Scout, Analyst, and Briefer. A new team member joins and runs hermes profile install github.com/you/research-dept. They get your three profiles, wiki structure, cron jobs, and SOUL.md templates. They add their own API keys and Telegram bot. Running in 10 minutes.

One Workflow, 15 Evolutions

Competitive research. Same task. Watch how it changes at every level.

1. Level 1: you type "what's new in AI agents this week?" and read a wall of text.
2. Level 2: the agent already knows your niche and competitors from SOUL.md. Same question, answer filtered to YOUR market.
3. Level 3: /background research competitors while you draft a proposal. Results appear without breaking flow.
4. Level 4: research skill on DeepSeek V4 Flash, analysis skill on Sonnet. You stop paying Opus prices for web searches.
5. Level 5: the agent checks Slack, email, and ClickUp BEFORE answering. "competitor launched yesterday. your team discussed it in #product."
6. Level 6: three sub-agents research three competitors in parallel, each on DeepSeek, parent on Sonnet synthesizes. 10 minutes instead of 30.
7. Level 7: you stopped asking. A cron job runs at 7am — wakeAgent gate: nothing changed = $0; competitor shipped an update = agent wakes, researches, delivers a brief to Telegram.
8. Level 8: Scout finds signals every 3 hours, Analyst synthesizes at 10am, Briefer delivers at 8am. Three profiles, one pipeline.
9. Level 9: findings go to the Obsidian wiki. Month 3: 300+ entries. The agent surfaces patterns you didn't ask about because the wiki found connections.
10. Level 10: quarterly analysis runs as a Kanban project — 12 cards with dependency chains. Agents pick up work as dependencies clear.
11. Level 11: driving to a meeting. Voice message: "anything from last night's research?" The agent responds with audio.
12. Level 12: competitor has no API. The agent opens their pricing page via browser, compares against last month's snapshot. Change detected.
13. Level 13: research runs as an API endpoint. A custom dashboard queries it. Your team sees competitive intel on a live page.
14. Level 14: coding a feature. Inside VS Code you ask "how does competitor X handle this?" The agent answers from your wiki without leaving the editor.
15. Level 15: your research setup is a git repo. A new team member runs one command — Scout, Analyst, Briefer, wiki structure, cron jobs — installed in 10 minutes.

Token Economics: Run All 15 Levels Without Burning Money

Every level above 3 costs tokens. Here are the controls that keep spending predictable.

• Right model per task (Level 4+): web search = DeepSeek V4 Flash ($0.10/M), synthesis = Sonnet ($3/$15/M), final review = Opus 4.8 ($5/$25/M). Assign models per skill, per profile, per cron job.
• wakeAgent gates (Level 7+): the script runs every tick for free and checks if anything changed. Nothing changed = the agent never wakes = $0.
• no_agent mode (Level 7+): when the script IS the job — uptime checks, disk alerts, file watchers. Output goes straight to Telegram. Zero LLM calls, ever.
• Pre-run scripts (Level 7+): a script gathers data for free; output is injected into the prompt as context. The model summarizes what the script fetched instead of burning tool calls.
• Lean tool sets (Level 5+): set --skills web,file per cron job. Fewer tool schemas = smaller prompt = cheaper. A news digest doesn't need browser, delegation, or kanban tools.
• Tool Search (Level 5+): auto-enabled when tool schemas eat 10%+ of context. Replaces full tool definitions with 3 bridge tools (~300 tokens instead of thousands). The agent discovers tools on demand.
• Compression threshold (Level 7+):

compression:
  threshold: 0.40    # default 0.50

Fires context compression earlier, keeping long /goal runs and cron sessions within budget even at 20+ turns.

• Curator — free by default (v0.17.0): deterministic skill pruning still runs for free; LLM-powered consolidation is now opt-in only.

curator:
  consolidate: true    # opt-in, default false

• Lossless densification (PR #47866 by teknium): search_files results get compressed before reaching the model. Same information, fewer tokens. Run hermes update.
• Auxiliary models for judge (Level 7+): the /goal judge runs after EVERY turn — route it to a cheap, fast model.

auxiliary:
  goal_judge:
    provider: openrouter
    model: google/gemini-3-flash-preview

• Budget caps (all levels):

budget:
  daily_max_usd: 10
  session_max_usd: 2
  monthly_max_usd: 200

Hard limits — the agent stops when it hits the cap. Set these before enabling any cron job or /goal run.

• Monitor spending: the Usage tab (Desktop app / Dashboard) shows a per-profile breakdown; /usage in any session shows per-session stats. Add "end with token spend this week" to Briefer prompts for weekly cost tracking in Telegram.

The pattern across all of these: push work off the expensive model onto free code, cheap models, and compressed context. The agent reasons; everything else runs for free.

Start with Blank Slate: if you care about token control from day one, install with Blank Slate mode (hermes setup → Blank Slate). Everything is disabled except provider, model, file tools, and terminal. Add features one by one as you need them — the cheapest, most controlled starting point.

Where Most People Stop

Levels 1-2. They install Hermes, write a SOUL.md, and use it as a smart chatbot. The agent saves them 30 minutes a day.

The jump from level 3 to level 7 is where daily time savings go from minutes to hours — /background, skills with the right models, cron jobs with wakeAgent gates. These compound.

The jump from level 7 to level 10+ is where the agent stops being a tool and becomes a system: multi-profile architecture, self-improving knowledge, Kanban orchestration. You review work that happened without you.

You do not need to reach level 15. Most solo founders operate well at levels 7-10. The levels above solve specific problems: voice for mobile workflows, browser for tools without APIs, API server for custom integrations, IDE for coding, distributions for teams. Pick the level that matches your bottleneck, set up that one, and move to the next when it stops being enough.

Official Sources

Features Overview · SOUL.md · Skills · Cron · Delegation · Goals · Profiles · Kanban · Voice & TTS · Browser Automation · API Server · ACP/IDE · Profile Distributions · Integrations Overview.

All technical details verified against Hermes Agent v0.17.0 documentation. Credit: @IBuzovskyi (YanXbt).