HASHI - Orquestração Universal de Agentes IA
Bazza1982/HASHI
Controle múltiplos LLMs localmente sem compartilhar tokens
Ver no GitHubPlataforma de orquestração multi-agentes que conecta Claude, Gemini e Codex via WhatsApp, Telegram ou interface web, sem armazenar tokens. Executa localmente com persistência de memória, agendamento automático, interação por voz e comportamento auto-melhorável através de feedback.
Instalação
npx convez-ai Bazza1982/HASHI1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Orquestração de múltiplos agentes IA especializados em uma interface unificada
- Automação de tarefas com memória persistente e auto-melhoria através de feedback
- Integração com WhatsApp/Telegram para acesso privado a agentes IA
Veredito

HASHI é um projeto ambicioso e maduro (v4.0.0-alpha) que genuinamente resolve o problema de privacidade em orquestração multi-agentes. Ideia criativa de 'vibe-coding' e arquitetura bem pensada, mas ainda em alpha — recomendado para construtores dispostos a contribuir em projeto em evolução, não para produção crítica.
README
A tradução para o português deste README ainda está na fila.
HASHI
Status (v4.0.0-alpha.1): HASHI 4 alpha introduces the Claw mode foundation and Superloop operational foundation on top of the v3.2.1 hotfix line. Claw mode adds a scoped
claw-clibackend, provider routing, packaged runtime discovery, and live repo-root read/write/edit validation. Grok CLI is now available as a CLI-authenticated flex backend with streaming JSON parsing, guarded empty-answer retry, and support-ecosystem audit coverage. Superloop alpha documents the runnable controller contract for taskboards, waits, HChat replies, evidence, and closeout barriers.Changelog: see
CHANGELOG.md· Roadmap: seedocs/ROADMAP.md· Nagare Docs: seedocs/NAGARE_FLOW_SYSTEM.md.
About
HASHI is a privacy-first, universal AI agent orchestration platform. It connects multiple LLM backends through a single interface, enabling multi-agent collaboration with persistent memory, automated scheduling, voice interaction, and self-improving behavior — all running locally on your machine.
Key principles:
- No Token Storage — CLI backends use local authentication; no OAuth tokens stored
- Multi-Agent, Single Interface — Chat with multiple specialized agents through one Telegram, WhatsApp, or Workbench session
- Self-Improving Agents — Habit system learns from
/goodand/badfeedback, with nightly dream reflection - Built to Evolve — Modular skills, tools, and backends can be added without touching core code
Project History & Name Origin
The Name: HASHI (ハシ / 橋)
HASHI means "bridge" in Japanese (橋).
The kanji 橋 combines:
- 木 (tree/wood) - the natural foundation
- 喬 (tall) - reaching upward, connecting heights
Project Philosophy:
「橋」は「知」を繋ぎ、「知」は未来を拓く。 The Bridge connects Intellect; Intellect opens the future.
Just as bridges connect distant shores, HASHI connects:
- Human creativity ↔ AI capabilities
- Multiple AI systems ↔ Unified interface
- Present workflows ↔ Future possibilities
Authorship & Credits
HASHI was conceived and designed from scratch by Barry Li (https://barryli.phd), a PhD candidate at the University of Newcastle, Australia.
Coming from a non-technical background with no prior IT experience, Barry built this project through "Vibe-Coding" — every line of code was generated by AI (Claude, Gemini, and Codex) and cross-reviewed by AI. Barry's role was that of System Architect and Director, providing the vision, operational judgment, and iterative direction. This marks Barry's first publishable AI project.
This project would not exist without OpenClaw by Peter Steinberg and the OpenClaw contributors. OpenClaw provided both a cutting-edge AI agent framework and the inspirational ideas that shaped this system. Deep thanks to Peter and all OpenClaw contributors.
Development Codename: bridge-u-f
Throughout the codebase, you'll see references to bridge-u-f — this was the internal development codename used during the project's evolution from OpenClaw.
u= universal (multi-backend, multi-agent)f= flexible (adaptive, modular, extensible)
Quick Technical Overview
HASHI is a universal multi-agent orchestration platform that runs entirely locally. It routes user requests to AI backends through a flexible adapter system, eliminating the need to store sensitive OAuth tokens.
Core Components:
- Onboarding — Multi-language guided setup to create your first agent
- Workbench — Local web UI (React + Vite) for multi-agent conversations
- Orchestrator — Central runtime managing agents, memory, skills, and scheduling
- Nagare Flow System — Multi-agent workflow orchestration engine
- Transports — Connect via Telegram, WhatsApp, or Workbench
- Skills — Modular capabilities (prompts, toggles, actions) that extend agents
- Jobs — Automated scheduling (heartbeats + cron) for periodic agent tasks
- Habit System — Self-improving behavior through feedback and nightly reflection
- HChat — Cross-instance agent-to-agent messaging
- API Gateway — Optional OpenAI-compatible localhost gateway with per-instance ports
What makes HASHI different:
- No Token Storage — Uses CLI backends with local authentication, not stored tokens
- 7 Backend Adapters — Claude CLI, Gemini CLI, Codex CLI, OpenRouter API, DeepSeek API, Ollama (local LLM), and Claw CLI
- Multi-Agent, Single Interface — Chat with multiple specialized agents through one account
- Nagare Flow System — Describe a task in natural language; Nagare designs, executes, and improves a multi-agent workflow automatically
- Self-Improving Agents — Habit system with
/goodand/badfeedback, nightly dream reflection, and cross-agent habit governance - SafeVoice — Voice messages are transcribed and shown for confirmation before execution, preventing accidental commands
- Context Recovery —
/handoffcommand instantly restores project context after compression - Tool Execution Layer — API-backed agents can take real local actions: run bash commands, read/write files, browse the web, call external APIs, and more
- Flex/Fixed Mode Switching — Agents can switch between CLI backends and API backends mid-conversation via
/backend - Wrapper Agent Mode — Pair a strong core model with a stateless persona wrapper so GPT/Codex can do the work while another model controls the final visible voice
- Anatta Live Self-Assembly — Optional per-agent mode (
off,shadow,on) that can observe or inject transient self-state guidance while keepingagent.mdas the stable identity - Cross-Instance Messaging — Agents across different HASHI instances can communicate via HChat and Hashi Remote
- EXP Guidebooks —
/explets agents consult context-specific operational playbooks, failure memory, validators, and training evidence before acting - Browser Route Dashboard —
/browserselects the right internet path: HASHI headless browser, CLI-native browsing, Brave Search, or the logged-in Chrome extension bridge - Hashi Remote File Transfer — move release artifacts, EXP packs, and other files directly between HASHI instances
- Audit Agent Mode — run a core model plus a separate auditor that emits follow-up findings without rewriting the core answer
- Pack & Go — Build a self-contained USB for Windows or macOS; recipients just plug in and double-click
- Vibe-Coded — Every line written by AI, reviewed by AI, directed by human vision
- Claw Mode Foundation —
claw-clican run as a scoped backend with provider routing, packaged runtime discovery, checksum-checked manifest metadata, and repo workzone read/write/edit validation - Superloop Operational Foundation — Long-running controller loops use explicit taskboards, waits, issue registers, HChat reply classification, and inbox-drain closeout barriers
Project Status
- v4.0.0-alpha.1 (current alpha release) — Claw mode foundation, packaged Claw runtime discovery, provider smoke probe, live momo repo-root read/write/edit validation, and Superloop operational contract
- v3.2.1 — Workbench API self-repair on
/reboot, HChat tool hot reload, and cross-instance route fallback hardening for multi-instance deployments - v3.2.0 — Slim core architecture, Wrapper Agent Mode, Audit Agent Mode, Anatta controls, EXP guidebooks,
/browserroute dashboard, Hashi Remote file transfer, per-instance API Gateway ports, OLL HASHI Chrome extension integration, Workzone support, runtime/backend hardening - v3.1 — Claude Opus 4.7, GPT-5.5, Codex CLI 0.125.0,
xhigh/maxeffort levels, HASHI Remote remediation - v3.0-beta — Self-improving agents, 6 LLM backends, SafeVoice, cross-instance messaging, token audit, agent behavior audit, remote backend policy, Minato MCP, Obsidian wiki integration
- v3.0-alpha — Ollama local LLM, habit system (Phase 4-5), TUI onboarding, Minato MCP (8-tier), token audit system, dream improvements
- v2.1.0 — Nagare Flow System — multi-agent workflow orchestration
- v2.0.0 — Tool execution layer, browser automation, Pack & Go USB deployment, TUI, vector memory,
/dreamskill
What's New Since v2
HASHI 2.x proved that local agents could execute tools, browse, switch backends, run from a TUI, and orchestrate Nagare workflows. HASHI 3.2 turns that foundation into a much broader local agent platform:
- From tools to agentic operations: the v2 tool layer is now surrounded by habit learning, nightly dream reflection, SafeVoice confirmation, token/cost audit, and behavior audit trails.
- From one machine to a HASHI network: HChat and Hashi Remote let agents address peers across instances, with peer health, protocol handshakes, and direct file transfer for moving artifacts and EXP packs.
- From backend switching to runtime composition: agents can run fixed, flex, wrapper, or audit modes, including a strong core model paired with a separate persona wrapper or auditor.
- From generic skills to learned expertise:
/expadds context-specific guidebooks with playbooks, validators, failure memory, templates, evidence, and training runs for repeatable high-skill work. - From browser automation to browser routing:
/browserexposes a route dashboard that chooses between headless browser tools, CLI-native browsing, Brave Search, and the real logged-in Chrome extension bridge. - From a monolith to a hot-reloadable core: v3.2's slim core moves frequently changed behavior into managers and runtime modules so
/reboot mincan adopt most code changes without a full process restart. - From scripts to a local work platform: Workbench, API Gateway, Workzone helpers, Nagare, Minato, and the EXP corpus now give HASHI a stronger operating surface for research, writing, office automation, and cross-device work.
Habit-Based Self-Improvement
HASHI agents learn from real usage over time. The habit system has two layers: user feedback signals that seed new habits, and nightly dream reflection that consolidates and evolves them.
User Feedback Signals
The simplest way to shape agent behavior — give direct feedback while working:
/skill good — agent did something right
/skill good always verify before asserting facts
/skill bad — agent did something wrong
/skill bad skipped verification, stated file existed without checking
Each signal captures the full conversation context. If an API key is available, the signal is processed into habits immediately; otherwise it is stored for the next dream run.
Dream — Nightly Reflection
Each night, agents run /skill dream to consolidate memory and process habit signals:
- Pending
/skill goodand/skill badsignals are analyzed (up to 3 per dream, paced to avoid overload) - New habit candidates are extracted from the conversation context and user comment
- Similar habits are reinforced rather than duplicated
- Habits accumulate evidence over time before being promoted to active
- Duplicate detection via mtime gate + content hash prevents redundant dream runs
Habit Governance (Lily-mediated)
A designated governance agent reviews habits across all agents and governs cross-agent reuse:
/skill habits report— regenerate evaluation report with Wilson-style evidence scoring/skill habits dashboard— advanced evaluation dashboard (task/class/backend breakdown)/skill habits list pending— inspect pending copy recommendations/skill habits approve <ids>//skill habits apply— approve and apply cross-agent copies/skill habits shared list— inspect active shared patterns and protocols/skill habits shared promote//skill habits shared retire— manage shared registry
Storage
All habit data is local-only and gitignored:
- Per-agent habits:
workspaces/<agent>/habits.sqlite - Shared evaluation:
workspaces/<governance_agent>/habit_evaluation.sqlite - Reports:
workspaces/<governance_agent>/habit_reports/
SafeVoice — Voice Confirmation
Voice messages can be misinterpreted by speech-to-text, potentially sending unintended commands to agents. SafeVoice adds a confirmation layer:
Voice message → Transcription → Preview text + [✅ Send] [❌ Cancel] buttons
↓ ↓
User confirms User cancels
↓ ↓
Sent to agent Discarded
- Default: ON for all agents (can be toggled per-agent with
/safevoice) - Preview limit: 3500 characters (Telegram's practical limit), with truncation notice for longer messages
- Timeout: 60 seconds auto-discard if no button pressed
- State persistence: Per-agent setting stored in workspace
state.json
Installation
See INSTALL.md for detailed installation instructions.
Nagare Core And Editor
The Nagare workflow engine ships as the nagare Python package, with the visual editor under nagare-viz/.
Core install and smoke check:
pip install .
python -m nagare.cli --help
pytest tests/contract/ -q
Editor install and smoke check:
cd nagare-viz
npm install
npm test
npm run build
Pack & Go — USB Zero-Install (Recommended for sharing)
Run HASHI on any Windows or macOS machine straight from a USB drive — no Python installation, no pip install, nothing to set up on the target machine.
Windows:
# On your machine (with internet):
windows\prepare_usb.bat # builds USB with embedded Python + all deps
# First time on any Windows PC:
windows\TUI_onboarding.bat # first-run setup + chat
# Subsequent launches:
windows\start_tui.bat # normal TUI chat
macOS:
# On your Mac (with internet):
bash mac/prepare_usb.sh # builds USB with portable Python + all deps
# On any Mac:
# Double-click mac/start_tui.command in Finder
Quick Start (Developer / Standard Install)
# Clone the repository
git clone https://github.com/Bazza1982/HASHI.git
cd HASHI
# Install Python dependencies
pip install -r requirements.txt
# First run — TUI onboarding (language, API key, Telegram setup)
python tui_onboarding.py
# Start HASHI
./bin/bridge-u.sh # macOS / Linux
bin\bridge-u.bat # Windows
python main.py # Any platform
Prerequisites
- Python 3.10+
- At least one AI backend:
- Gemini CLI (
gemini) - Claude Code (
claude) - Codex CLI (
codex) - OpenRouter API key
- DeepSeek API key
- Ollama (local LLM, no API key needed)
- Gemini CLI (
- Optional: Node.js 18+ (for Workbench UI)
Comprehensive Technical Details
Architecture
HASHI uses a Universal Orchestrator pattern where a single Python process manages multiple concurrent agent runtimes:
┌──────────────────────────────────────────────────────────────────┐
│ Universal Orchestrator │
│ │
│ ┌────────────────┐ ┌────────────────┐ ┌────────────────┐ │
│ │ Agent Runtime │ │ Agent Runtime │ │ Agent Runtime │ ... │
│ │ (Agent A) │ │ (Agent B) │ │ (Agent C) │ │
│ └────────────────┘ └────────────────┘ └────────────────┘ │
│ ▲ ▲ ▲ │
│ └──────────────────┴──────────────────┘ │
│ │ │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Flexible Backend Manager │ │
│ │ ┌────────┐ ┌────────┐ ┌────────┐ ┌──────────┐ │ │
│ │ │Gemini │ │Claude │ │ Codex │ │OpenRouter│ │ │
│ │ │Adapter │ │Adapter │ │Adapter │ │ Adapter │ │ │
│ │ └────────┘ └────────┘ └────────┘ └──────────┘ │ │
│ │ ┌──────────┐ ┌────────┐ │ │
│ │ │DeepSeek │ │ Ollama │ │ │
│ │ │ Adapter │ │Adapter │ │ │
│ │ └──────────┘ └────────┘ │ │
│ └────────────────────────────────────────────────────────────┘ │
│ ▲ │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Transport Layer │ │
│ │ [Telegram] [WhatsApp] [Workbench API] [HChat] │ │
│ └────────────────────────────────────────────────────────────┘ │
│ │
│ ┌────────────┐ ┌────────────┐ ┌────────────────────┐ │
│ │ Skill │ │ Scheduler │ │ Memory System │ │
│ │ Manager │ │ (Jobs/Cron)│ │ (Vector + Recall) │ │
│ └────────────┘ └────────────┘ └────────────────────┘ │
│ │
│ ┌────────────────────────────┐ ┌────────────────────────┐ │
│ │ Habit System │ │ Token Audit │ │
│ │ (Feedback → Dream → Grow) │ │ (Usage + Cost Track) │ │
│ └────────────────────────────┘ └────────────────────────┘ │
│ │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Nagare Flow System │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────────────┐ │ │
│ │ │FlowRunner│→ │ Workers │→ │ Evaluation KB │ │ │
│ │ │(DAG Orch)│ │(Multi-AI)│ │(Self-Improving) │ │ │
│ │ └──────────┘ └──────────┘ └──────────────────┘ │ │
│ └────────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────┘
Key Design Principles:
- Backend Agnostic — Agents work with any supported backend; you can switch mid-conversation
- Shared Sessions — Telegram and Workbench share the same agent queues and memory
- Explicit over Automatic — Skills, jobs, and features are user-activated, never magic
- Single Instance — File-based locking prevents multiple HASHI processes from conflicting
- Remote Backend Policy — API backends (OpenRouter, DeepSeek) are reserved for user-initiated requests; automated flows use CLI backends to prevent runaway costs
- Slim Core — process bootstrap stays small while hot-reloadable managers own feature behavior
File Structure
hashi/
├── main.py # Slim process bootstrap and kernel wrapper
├── agents.json # Agent definitions (name, backend, system prompt)
├── secrets.json # API keys (gitignored)
├── tasks.json # Heartbeat + cron job definitions
├── onboarding/ # Multi-language guided setup
│ └── languages/ # 9 languages
├── orchestrator/ # Hot-reloadable orchestration managers and runtime logic
│ ├── config_admin.py # Config administration manager
│ ├── backend_preflight.py # Backend availability/preflight manager
│ ├── agent_lifecycle.py # Agent start/stop/teardown manager
│ ├── service_manager.py # Workbench, API gateway, scheduler services
│ ├── reboot_manager.py # /reboot reload and manager rebuild flow
│ ├── startup_manager.py # Cold-start orchestration
│ ├── shutdown_manager.py # Final shutdown orchestration
│ ├── whatsapp_manager.py # WhatsApp control manager
│ ├── agent_runtime.py # Legacy fixed-runtime compatibility shim
│ ├── legacy/ # Retired fixed runtime, emergency flag only
│ ├── flexible_agent_runtime.py # Flex agent (switchable backend)
│ ├── scheduler.py # Heartbeat + cron job runner
│ ├── skill_manager.py # Skills system
│ ├── bridge_memory.py # Context assembly + memory retrieval
│ ├── habits.py # Habit evaluation and governance
│ ├── voice_manager.py # TTS and voice reply management
│ ├── workbench_api.py # Workbench REST API server
│ └── api_gateway.py # External API gateway (optional)
├── adapters/ # Backend adapters
│ ├── base.py # Abstract base adapter
│ ├── gemini_cli.py # Google Gemini CLI
│ ├── claude_cli.py # Anthropic Claude Code
│ ├── codex_cli.py # OpenAI Codex CLI
│ ├── openrouter_api.py # OpenRouter API
│ ├── deepseek_api.py # DeepSeek API (direct)
│ ├── ollama_api.py # Ollama local LLM
│ └── registry.py # Backend auto-discovery
├── skills/ # Skill library
│ ├── dream/ # Nightly memory consolidation
│ ├── good/ & bad/ # Habit feedback signals
│ ├── habits/ # Habit governance surface
│ ├── agent_audit/ # Agent behavior audit
│ └── [custom_skills]/ # User-defined skills
├── tools/ # Tool execution layer
│ ├── builtins.py # 11+ built-in tool executors
│ ├── schemas.py # Tool JSON Schema definitions
│ ├── registry.py # ToolRegistry dispatcher
│ ├── hchat_send.py # Cross-instance agent messaging
│ └── telegram_send_file_cli.py # File sending via Telegram
├── nagare/ # Nagare workflow engine (standalone package)
├── nagare-viz/ # Visual workflow editor (React + TypeScript)
├── flow/ # Legacy flow system + HASHI adapter
├── remote/ # Hashi Remote (cross-network agent communication)
├── workbench/ # Local web UI (React + Vite + Node.js)
├── tui.py # Terminal UI (Textual)
├── tui_onboarding.py # First-run TUI setup
├── scripts/ # Utility scripts
│ ├── token_audit.py # Token usage analysis
│ ├── generate_agent_behavior_audit.py # Agent behavior report
│ ├── wiki_organise.py # Obsidian wiki data prep
│ └── consolidate_memory.py # Memory consolidation
├── workspaces/ # Agent working directories (gitignored)
├── memory/ # Agent memory files (gitignored)
├── state/ # Runtime state (gitignored)
└── logs/ # Log files (gitignored)
Onboarding System
First-run setup is handled by the TUI Onboarding program, which runs entirely inside the terminal UI.
Entry points:
- Windows:
windows/TUI_onboarding.bat(double-click) - Developer:
python tui_onboarding.py
First-run flow:
- Language selection — 9 languages
- AI Ethics & Human Well-being disclaimer — Enter to confirm
- Mental health & AI relationship reminder — Enter to confirm
- API key check — auto-detects OpenRouter or DeepSeek key with live ping; prompts for a key if none found
- Generates
agents.jsonfrom sample if not present - Bridge starts — TUI transitions seamlessly into normal chat
- First agent greets the user in their selected language and guides Telegram setup
Connections (Transports)
HASHI supports multiple communication channels:
Telegram
- Default transport, enabled by default
- Requires
telegram_bot_tokeninsecrets.json - Commands:
/new,/fresh,/stop,/reboot,/handoff,/skill, etc. - Supports inline keyboards, file uploads, voice messages, SafeVoice
- File sending (photos, documents, videos, audio) from agents
- Uses
whatsapp-web.jslibrary - Requires QR code scan on first launch (agent can relay QR via Telegram)
- Multi-Agent Support — route messages to different agents using
/agent <name>prefix
Workbench
- Local web UI (React + Vite)
- No authentication required (localhost only)
- Shared sessions with Telegram/WhatsApp
HASHI API & API Gateway
- HASHI API is the internal Workbench API and listens on each instance's
global.workbench_port. - API Gateway is the optional OpenAI-compatible gateway enabled with
--api-gateway. /apicontrols the API Gateway from Telegram with inline buttons: status, on, off, and default-model selection.- If
global.api_gateway_portis omitted, HASHI derives it asworkbench_port + 1. - Common local layout: HASHI1
18800/18801, HASHI218802/18803, HASHI918819/18820. GET /api/healthreports instance, Workbench port, API Gateway port, gateway enabled state, and online agents after restart.
WatchTower Rescue & Cold Restart
- HASHI WatchTower is an always-on side service used for LAN rescue and cold restart of HASHI instances.
- WatchTower can stay alive when the HASHI process, Telegram runtime, or Workbench API is down.
/restartasksWATCHTOWERto perform a supervised hard restart: stop the HASHI process, start it again through the configured launcher, and verify Workbench health.- Rescue and restart actions use fixed control endpoints, shared-token/HMAC authentication, audit logs, and restart state files. They are not generic shell execution.
HChat — Cross-Instance Agent Messaging
namemeans local-instance delivery onlyname@INSTANCEmeans cross-instance delivery via Hashi Remote- Each HASHI instance has its own direct P2P identity (e.g.,
@hashi2); no central relay required - Routing: local Workbench exchange API → Hashi Remote registry lookup → direct delivery to target
/hchator/protocol/message - Fallback path: if the exchange endpoint is unavailable, direct Remote delivery is attempted automatically
- JSON protocol preserves sender agent identity, sender instance, and TTL for loop prevention
- Reply path: remote instance delivers reply directly back to the originating instance via Hashi Remote
Commands
HASHI agents respond to both natural language and structured commands:
Universal Commands
| Command | Description |
|---|---|
/new | Start a fresh CLI session |
/fresh | Start a clean API context without deleting saved memories |
/stop | Cancel current processing |
/reboot [min|max|#] | Hot restart agents |
/restart | Hard restart this HASHI instance through WatchTower supervision |
/status [full] | Show agent status, backend info |
/handoff | Restore continuity from recent transcript |
/skill | Browse and run skills (inline keyboard) |
/exp <task> | Run a task after consulting context-specific EXP guidebooks |
/help | Show available commands |
Session & Mode Commands
| Command | Description |
|---|---|
/mode [fixed|flex|wrapper] | Switch between fixed CLI session, flex multi-backend mode, and wrapper mode |
/backend [engine] | Switch backend (flex mode only) |
/model | View/change active model |
/core | View/change wrapper-mode functional core backend/model |
/wrap | View/change wrapper-mode persona wrapper backend/model/context |
/wrapper | View/edit wrapper-mode persona/style slots |
/anatta [status|off|shadow|on] | Inspect or switch Anatta live self-assembly mode for the current agent |
/effort | View/change effort level (Claude/Codex only) |
/fyi [prompt] | Refresh bridge environment awareness |
/usecomputer [on|off|status|examples|task] | Load managed GUI-aware computer-use guidance; prefers non-GUI methods first |
/browser [status|examples|1-4 task] | Direct an internet task through a selected browser/search route |
/retry | Resend last response or re-run last prompt |
/long ... /end | Buffer long text across multiple messages, submit as one |
/loop <interval> <task> | Create recurring automated tasks via skill injection |
Toggles & Settings
| Command | Description |
|---|---|
/verbose [on|off] | Toggle detailed status; in wrapper mode, on also shows core raw output and wrapper final output |
/think [on|off] | Toggle thinking trace display |
/safevoice [on|off] | Toggle voice confirmation (default: ON) |
/active [on|off|minutes] | Toggle proactive heartbeat |
/whisper [small|medium|large] | Set local voice transcription model |
/voice [on|off|menu|use <alias>] | Control bridge voice replies |
/say | Read the last assistant reply as voice; forces one TTS attempt even when /voice off if a voice is configured |
/api [status|on|off|model <name>] | Show API Gateway address, switch it on/off, or set its default model |
Lifecycle Commands
| Command | Description |
|---|---|
/start [all|<name>] | Start a stopped agent |
/terminate | Shut down agent gracefully |
/jobs | Show jobs with action buttons (run, enable/disable, transfer, delete) |
Skills System
Skills are modular capabilities that extend agent functionality. Every skill is defined by a skill.md file with frontmatter + instructions.
Skill Types
| Type | Behavior | Example |
|---|---|---|
| Action | One-shot execution, runs a script | dream, agent_audit, system_status |
| Prompt | Routes user input to a backend/tool | codex, gemini, claude |
| Toggle | Injects instructions while active | TTS, carbon-accounting, academic-writing |
Built-in Skills
| Skill | Type | Description |
|---|---|---|
dream | Action | Nightly memory consolidation + behavioral reflection |
good / bad | Action | Habit feedback signals |
habits | Action | Habit governance dashboard and approval surface |
agent_audit | Action | Local-only agent behavior audit report |
cron | Action | Cron job management |
heartbeat | Action | Heartbeat job management |
recall | Toggle | Auto-restore continuity after restart |
Using Skills
/skill → Show skill grid (Telegram inline keyboard)
/skill help → List all skills
/skill <name> → Show skill info
/skill <name> <prompt> → Run prompt skill with input
/skill <name> on → Enable toggle skill
/skill <name> off → Disable toggle skill
Job System (Scheduler)
HASHI includes a built-in task scheduler for automated agent actions:
Heartbeats
Periodic checks at fixed intervals:
{
"id": "email-check",
"enabled": true,
"agent": "hashiko",
"interval_seconds": 1800,
"prompt": "Check my email for urgent messages"
}
Cron Jobs
Scheduled tasks at specific times:
{
"id": "morning-briefing",
"enabled": true,
"agent": "hashiko",
"time": "08:00",
"prompt": "Provide morning briefing"
}
Skill-Based Jobs
Jobs can invoke skills instead of prompts:
{
"id": "nightly-dream",
"enabled": true,
"agent": "hashiko",
"time": "01:30",
"action": "skill:dream"
}
/loop — Recurring Tasks via Natural Language
/loop every 20 minutes check paper progress, stop when done
The /loop command uses skill injection — it appends system guidance to your message, letting the LLM understand the task, interval, and stop conditions, then autonomously create the appropriate cron entries.
Job Transfer
Jobs can be transferred between agents (same instance or cross-instance):
/jobs → click [Transfer] → select target agent → done
Backend Adapters
HASHI's adapter system provides a unified interface to multiple AI backends:
Supported Backends
| Backend | Engine ID | Requirements | Notes |
|---|---|---|---|
| Gemini CLI | gemini-cli | gemini CLI installed | Local auth |
| Claude Code | claude-cli | claude CLI installed | Local auth |
| Codex CLI | codex-cli | codex CLI installed | Local auth |
| Grok CLI | grok-cli | grok CLI installed and logged in | Local auth, streaming JSON |
| OpenRouter API | openrouter-api | API key in secrets.json | Multi-model access |
| DeepSeek API | deepseek-api | API key in secrets.json | Direct API, cost-effective |
| Ollama | ollama-api | Ollama installed locally | Free, no API key needed |
Remote Backend Policy
API backends (OpenRouter, DeepSeek) are protected by an automatic cost-control policy:
- User-initiated requests → allowed on any backend
- Automated requests (scheduler, HChat, transfers) → blocked on remote API backends, must use CLI or local backends
This prevents runaway API costs from automated workflows.
CLI Backends (Gemini, Claude, Codex, Grok)
- Spawn subprocess and communicate via stdin/stdout
- No OAuth tokens stored — uses local CLI authentication
- Full tool support
- Conversation memory managed by CLI
- Grok CLI uses
--output-format streaming-json; HASHI treats zero-exit empty answers as failures, retries once only for side-effect-freethought/endempty output, and refuses retry after side-effect events.
API Backends (OpenRouter, DeepSeek)
- HTTP API with streaming support
- Supports tool calls (function calling)
- Stateless (HASHI manages conversation history)
- Per-agent API key overrides supported
Ollama Backend
- Connects to locally-hosted LLMs
- Intelligent context scaling — smaller models get reduced context injection
- No API key required
Tool Execution Layer
API-backed agents can execute local actions via the tool system:
{
"engine": "openrouter-api",
"model": "anthropic/claude-sonnet-4.6",
"tools": {
"allowed": ["bash", "file_read", "file_write", "file_list", "apply_patch",
"web_search", "web_fetch", "http_request",
"process_list", "process_kill", "telegram_send"],
"max_loops": 15
}
}
Available tools:
| Tool | Description |
|---|---|
bash | Run shell commands (sandboxed, timeout + blocklist controls) |
file_read | Read files with offset/limit pagination |
file_write | Write/create files |
file_list | List directories with glob filter |
apply_patch | Apply unified diff patches |
process_list | List running processes |
process_kill | Send signals to processes |
telegram_send | Send Telegram messages |
telegram_send_file | Send files via Telegram (photos, documents, video, audio) |
http_request | Arbitrary HTTP requests for external APIs |
web_search | Brave Search API integration |
web_fetch | Fetch any URL as Markdown |
browser_screenshot | Navigate to URL and capture screenshot |
browser_get_text | Extract visible text from rendered page |
browser_click / browser_fill / browser_type_text | Interact with web elements (type_text uses CDP for React/contenteditable editors) |
desktop_screenshot | Capture Linux virtual desktop (Xvfb/XRDP) as base64 PNG |
desktop_click | Click at (x, y) on the virtual desktop |
desktop_type | Type text into focused window (all chars via xdotool) |
desktop_key | Press key combos: ctrl+s, alt+F4, Return, etc. |
desktop_mouse_move | Move mouse to absolute coordinates |
desktop_scroll | Scroll mouse wheel in any direction |
desktop_info | Query display info and current mouse position |
windows_screenshot | Capture the real Windows desktop as base64 PNG |
windows_click / windows_type | Interact with the real Windows desktop |
windows_key / windows_mouse_move / windows_scroll | Send Windows desktop input |
windows_info | Query Windows-side mouse / display / window info |
windows_window_list / windows_window_focus / windows_window_close | Enumerate and control Windows top-level windows |
No tools key in config = tools disabled, fully backward compatible.
/usecomputer Consolidated Command
/usecomputer is a unified operator shortcut for tasks that may require browser, desktop, or full GUI control.
- It is not a forced GUI mode.
- It loads managed guidance so the agent knows to use computer interaction when needed.
- It prefers direct APIs, shell commands, and file edits first when those are more reliable.
- When GUI work is necessary, it chooses between
desktop_*andwindows_*based on the target environment. - Alias:
/usercomputer
Examples:
/usecomputer on
/usecomputer status
/usecomputer Please do some qualitative coding for me in NVivo here, using mouse and keyboard if needed.
/usecomputer Please verify this Chrome extension on the real Windows desktop.
/browser Internet Route Command
/browser is a lightweight operator shortcut for internet-facing tasks. It does not execute browser actions directly; it sends the current agent a clear route-specific instruction so the agent chooses the intended tool family.
Routes:
| Route | Use |
|---|---|
1 | HASHI standalone/headless browser tools for public or JavaScript-heavy pages |
2 | CLI backend native browsing/search where supported by Codex CLI, Claude CLI, or Gemini CLI |
3 | HASHI Brave Search (web_search) plus public page fetching (web_fetch) |
4 | HASHI browser extension bridge for the logged-in Windows browser when authentication is required |
Examples:
/browser
/browser status
/browser 1 Inspect this public dashboard and summarize the visible table.
/browser 3 Find recent sources about mandatory CSR assurance.
/browser 4 Open the logged-in library page and download the PDF I am entitled to access.
/browser and /browser status render the same status dashboard. Traffic
lights mean: green = confirmed online and usable, yellow = unknown/not checked,
red = offline or misconfigured. The HASHI standalone/headless route is built in
and should be shown as available when Hashi is running; Brave and extension
routes report their live configuration status.
Windows Live Browser Bridge — Known Good Workflow
The Windows desktop-control tier is now good enough to drive a real Windows Chrome extension recovery / verification loop.
On multi-display Windows hosts, do not assume the first screenshot is the only screen. Start with windows_info and inspect displays, choose the target monitor, then call windows_screenshot(display=N) for that screen. Pair screenshots with windows_window_list / windows_window_focus; visual confirmation alone is not enough when windows can live on different monitors or focus can fail silently.
Recommended workflow for agents:
- Use
windows_infoand inspectdisplays. - Capture
windows_screenshot(display=N)for the monitor that should contain the real Chrome window. - Use
windows_window_listto find the real Chrome window. - Use
windows_window_focuson that window. - Re-capture
windows_screenshot(display=N)before typing if focus matters. - Drive navigation with:
windows_key→ctrl+lwindows_type→ target URLwindows_key→ENTER
- Verify the extension bridge through bridge-owned evidence, not only by what the desktop looks like:
- native host log:
logs/browser_native_host.log - socket:
/tmp/hashi-browser-bridge.sock tools.browser_extension_bridge.healthcheck(...)
- native host log:
- On real pages, verify:
active_tabget_textscreenshot
What the installed Windows extension is confirmed to do:
active_tabget_textget_htmlscreenshotclickfillevaluate
Important detail:
active_tab(args.url=...)is a real control action, not just inspection.- It can drive the active Windows Chrome tab to a target URL and wait for load completion.
- That makes it usable for authenticated-session checks too, as long as the user's Chrome session is already logged in.
Known-good Windows live results have been verified on:
- Google Scholar
- Wikipedia
- arXiv
- Gmail inbox access through the user's already logged-in Chrome session
Known-good Windows live interaction details:
- after editing an unpacked extension already running in Chrome, a plain browser restart was not always enough to pick up the new service worker code
- on this host, the reliable update sequence was:
- focus the real Chrome window
- open
chrome://extensions - press
Tab11 times - press
Enter
- this was the sequence that moved the live bridge from:
unsupported action: fillunsupported action: evaluateto:- real
fill,click, andevaluateexecution
evaluateis now known-good when executed in the page main world:evaluate('document.title')returnedWikipediaevaluate('JSON.stringify({title: document.title})')returned serialized JSON
fillsuccessfully wroteOpenAIinto the Wikipedia search inputclick('button[type="submit"]')triggered real navigation to Wikipedia search results
Known caveats:
chrome://pages are often non-scriptable, soget_textcan fail there by design.screenshotcan fail on Chrome internal pages before the extension has an effective page-level invocation.- The visible Windows Chrome UI can be misleading:
- a narrow side window or suggestions overlay may remain visible
- the bridge itself can still be healthy behind that UI
- When desktop visuals and bridge status disagree, prefer bridge-owned evidence:
- socket
- native host log
- Chrome profile extension state
Memory System
HASHI includes a vector-based memory system for long-term context retrieval:
How It Works
- Automatic storage — relevant conversation turns are embedded and saved to
bridge_memory.sqlite - Vectorized search — text embedded using BGE-M3 (local ONNX) when available, falling back to hash-based similarity
- Context assembly — top-K similar memories retrieved via cosine similarity and injected into prompts
- Memory control —
/memorycommand for surgical control (status, pause, wipe, on/off)
Memory in Prompts
Every agent request includes assembled context:
--- SYSTEM IDENTITY ---
{agent.md contents}
--- ACTIVE SKILLS ---
{active toggle skills}
--- ACTIVE HABITS ---
{habits learned from feedback}
--- RELEVANT LONG-TERM MEMORY ---
{top retrieved memories}
--- RECENT CONTEXT ---
{recent conversation turns}
--- NEW REQUEST ---
{user message}
Token Audit & Cost Tracking
HASHI tracks token consumption across all backends:
- API backends — use exact
usagedata from API responses - CLI backends — estimate based on message content + system prompt + context
- Audit log —
token_usage.jsonlwith per-turn breakdown - Analysis script —
scripts/token_audit.pyfor usage reports and cost analysis
Nagare Flow System
Nagare (流れ) is HASHI's multi-agent workflow orchestration engine.
Key Capabilities:
| Capability | How It Works |
|---|---|
| Meta-Workflow | Describe a task in natural language → Nagare designs a complete workflow |
| Cross-Vendor Evaluation | Claude writes → GPT reviews. No model evaluates its own output |
| Pre-Flight System | All human decisions collected upfront; workflow runs uninterrupted |
| DAG Orchestration | Steps execute in dependency order with parallel execution |
| Debug Agent | Auto-recovers from failures (3 attempts) before human escalation |
| Evaluation KB | Every run feeds lessons back — workflows improve over time |
| Crash Recovery | Atomic state persistence, resume at exact failure point |
Quick Start:
python -m nagare.cli --help
Full technical reference:
docs/NAGARE_FLOW_SYSTEM.md
/long ... /end — Long Text Handling
Telegram splits long messages automatically, which can cause incomplete understanding. The /long command buffers all fragments:
/long ← start collecting (optional: /long first line)
(paste long text — Telegram splits into multiple messages)
(all messages silently buffered, no LLM triggered)
/end ← assemble and submit as one message
Safety: 5-minute auto-submit timeout, empty buffer warning, duplicate /long detection.
Hashi Remote
Hashi Remote is the P2P communication layer that gives each HASHI instance a direct, addressable network identity. It runs as an independent sidecar service and can be started or stopped via /remote on / /remote off without restarting the core HASHI process.
Peer Discovery
- LAN discovery — mDNS advertisement and scanning over
_hashi._tcp.local.; finds instances on the same network automatically with no configuration - Tailscale discovery — polls Tailscale status for internet-connected instances, enabling cross-location communication through a private overlay network
- Multi-backend merge — observations from LAN and Tailscale for the same instance are merged into a single canonical peer record; duplicate entries are suppressed
- Persistent registry — discovered peers and their last-known addresses are persisted to
instances.jsonand survive restarts
Protocol Handshake
When a peer is discovered, Hashi Remote performs a mutual handshake before any messaging:
- Exchanges protocol version and capability list
- Transfers a live snapshot of the local agent directory (so each side knows what agents the other hosts, e.g.,
rika@hashi2) - Reverse-registers the caller as a peer from the receiver's perspective (bi-directional registration from a single handshake)
- Revalidates every 30 seconds to confirm continued liveness; state transitions:
handshake_pending → handshake_in_progress → handshake_accepted - Authenticates
/protocol/handshakeand/protocol/messagewithhashi-shared-hmac-v1when a shared token is configured - Missing shared token starts Remote in
discovery-onlymode: peers can be seen, but trusted protocol messaging, full peer details, file transfer, and rescue controls are unavailable
Peer Liveness
- Each peer tracks
last_seen_ok,last_handshake_at,consecutive_failures, and a derivedlive_status - Status thresholds: online (seen ≤ 75s, no failures) · stale (≤ 150s or 1 failure) · offline (otherwise)
- Live status is recomputed on every rebuild; stale observations never overwrite runtime liveness
- Bootstrap self-healing repairs stale non-WSL LAN peers when a persisted
instances.jsonorremote_live_endpoints.jsonroute points at an obsolete Remote port. Existing healthy peers are left untouched; existingoffline/handshake_timed_outpeers may be re-probed and replaced with a verified route.
Same-Host Routing
- Instances on the same machine, including WSL/Windows co-location, are detected via host identity, WSL root hints, and address candidates
- Same-host peers are routed through
127.0.0.1loopback with unique Remote ports - Cross-host peers avoid loopback and prefer LAN/Tailscale/configured hosts
/protocol/statusreports same-host Remote port conflicts throughroute_diagnostics- Remote does not blindly assume all peers use
8766. The8766fallback is only used for explicit non-WSL LAN peers such as Windows/Linux/macOS hosts. WSL peers must keep their configured unique ports so same-host multi-instance deployments like HASHI1/HASHI2 do not cross-wire.
P2P Message Protocol
Direct agent-to-agent messaging over Hashi Remote (/protocol/message):
- TTL-based loop prevention — each message carries a hop count; messages exceeding the limit are dropped
- Deduplication — message IDs are tracked to suppress duplicate deliveries
- In-flight tracking — sent messages are persisted to
~/.hashi-remote/protocol_inflight_<id>.json; state is recovered across restarts - Reply correlation — the sending instance polls for a reply (soft timeout 45s, hard timeout 180s) and forwards it back to the originating agent
- Agent directory resolution — target
agent@instanceaddresses are resolved against the live peer registry before delivery
Security
- TLS encryption on all remote connections
- Shared-token HMAC for trusted protocol traffic; configure
HASHI_REMOTE_SHARED_TOKENorsecrets.jsonkeyhashi_remote_shared_token - Public
/health,/peers, and/protocol/statusresponses are redacted unless the caller is loopback or authenticated - Pairing-based client authentication remains available for non-protocol endpoints; LAN mode is off by default for protocol trust
- Auth-gated terminal execution delegation (
/terminal/exec) - Full audit logging for all inbound hchat and remote operations
Rescue Control
For crash recovery, Hashi Remote should be run under an OS-level supervisor
rather than only through /remote on. The fixed rescue protocol exposes
GET /control/hashi/status, GET /control/hashi/logs, and
POST /control/hashi/start; start is blocked unless Remote is launched with
max_terminal_level=L3_RESTART. See
docs/HASHI_REMOTE_RESCUE_PROTOCOL.md.
For rollout and rollback notes, see
docs/HASHI_REMOTE_MIGRATION.md.
Diagnostics
GET /peers— live peer list with liveness status, route kind, and agent directoryGET /protocol/status— full protocol state: handshake states, in-flight count, local network profile, agent snapshotGET /health— instance info and peer summary/remote listshould agree with/peers: a peer that is reachable by hchat but still shown offline in/remote listmeans the Remote registry is stale and should be refreshed or restarted after pulling the latest code.
Cross-Instance Messages, Attachments, And File Push
For trusted cross-instance operations on LAN or Tailscale peers:
- Hchat tool:
python tools/hchat_send.py --to agent@INSTANCE --from <agent> --text "<msg>" - plain message:
python tools/protocol_send.py --to agent@INSTANCE --from <agent> --text "<msg>" --shared-token "$HASHI_REMOTE_SHARED_TOKEN" - message with attachment:
add
--attach <file>and require peer capabilitymessage_attachments_v1 - file push:
python tools/remote_file_transfer.py --shared-token "$HASHI_REMOTE_SHARED_TOKEN" --from-instance HASHI1 push ./file.txt INSTANCE:incoming/remote_smoke/file.txt - file stat:
python tools/remote_file_transfer.py --shared-token "$HASHI_REMOTE_SHARED_TOKEN" --from-instance HASHI1 stat INSTANCE:incoming/remote_smoke/file.txt
The Remote tools now probe live /protocol/status before shared-token file
transfer and attachment sends so stale peer metadata produces a clear
capability error instead of ambiguous 401 or 404 failures.
tools/hchat_send.py now prefers the newer shared-token protocol transport for
cross-instance agent@INSTANCE delivery and only falls back to legacy
/hchat relay when protocol transport is unavailable. This fixes the legacy
transport mismatch where /protocol/message worked but /hchat could still
fail with bearer-only authorization behavior.
Windows/LAN peers may bind the local Workbench API to a LAN IP rather than
127.0.0.1. Hashi Remote now widens local Workbench host fallback to include
real interface IPv4 addresses, which fixes the case where protocol transport
reaches the peer but local enqueue fails on an otherwise healthy LAN PC.
For stale LAN routes, tools/hchat_send.py and Hashi Remote now use the same
live route model. Hchat refreshes from state/remote_live_endpoints.json, while
Remote bootstrap can repair an offline peer whose persisted port is obsolete
once the peer is reachable on its verified Remote port. After upgrade, validate
both surfaces:
/remote list
python tools/hchat_send.py --to agent@INSTANCE --from <agent> --check
curl http://127.0.0.1:<local-remote-port>/peers
Configuration Files
Private Commands
Custom slash-command modules can live outside the repository at:
~/.hashi/private_commands/*.py
Each module may expose COMMANDS = [...] or get_commands() -> list[RuntimeCommand].
For inline button handlers, expose CALLBACKS = [...] or
get_callbacks() -> list[RuntimeCallback]. HASHI loads these modules when
runtime handlers are bound; after adding or editing a private command, run
/reboot min for the target agent or cold-restart HASHI.
agents.json
{
"global": {
"authorized_id": 123456789,
"default_tools": {
"allowed": ["bash", "file_read", "file_write", "file_list"]
}
},
"agents": [
{
"name": "hashiko",
"type": "flex",
"display_name": "Hashiko",
"system_md": "workspaces/hashiko/agent.md",
"workspace_dir": "workspaces/hashiko",
"is_active": true,
"telegram_token_key": "hashiko",
"allowed_backends": ["gemini-cli", "claude-cli", "openrouter-api", "deepseek-api", "ollama-api"],
"active_backend": "gemini-cli"
}
]
}
Every agent must set type explicitly. New agents should normally use
"type": "flex". Omitted type is rejected so HASHI cannot accidentally fall
back to the retired legacy fixed runtime. Explicit "type": "fixed" is reserved
for emergency rollback only and requires HASHI_ENABLE_LEGACY_FIXED_RUNTIME=1.
secrets.json
{
"hashiko": "your_telegram_bot_token",
"openrouter_key": "sk-or-v1-...",
"deepseek_api_key": "sk-...",
"brave_api_key": "BSA...",
"authorized_telegram_id": 123456789
}
tasks.json
{
"heartbeats": [
{ "id": "check-email", "enabled": true, "agent": "hashiko", "interval_seconds": 1800, "prompt": "Check email" }
],
"crons": [
{ "id": "morning-brief", "enabled": true, "agent": "hashiko", "time": "08:00", "prompt": "Morning briefing" },
{ "id": "nightly-dream", "enabled": true, "agent": "hashiko", "time": "01:30", "action": "skill:dream" }
]
}
Debugging and Logs
Log Files
| Log | Location | Contents |
|---|---|---|
| Bridge log | logs/bridge.log | Orchestrator events, backend checks, agent state |
| Session errors | logs/<session>/errors.log | Per-session error details |
| Launch log | logs/bridge_launch.log | Startup sequence |
| Token audit | logs/token_usage.jsonl | Token consumption records |
Common Issues
"bridge-u-f is already running"
- Another instance is active; kill it or use a separate instance directory
"No CLI backends detected"
- Install Gemini/Claude/Codex CLI, or provide an API key during onboarding
Telegram bot not responding
- Check
telegram_bot_tokeninsecrets.json - Verify
authorized_idmatches your Telegram user ID - Ensure only one instance uses each bot token (polling conflict)
Agent stuck in LOCAL MODE
- Usually network-related; check internet connectivity
- Review
bridge.logfor preflight timeout errors
TUI Interface
tui.py provides a terminal-first interface built with Textual:
python tui.py
Panels:
- Log panel (upper) — real-time stdout/stderr from the bridge process
- Chat input bar (lower) — send messages to any active agent
- Status bar — current agent, backend, bridge uptime
- Agent selector — hotkey to switch which agent receives input
Warnings
This is Version v4.0.0-alpha.1
HASHI v4.0.0-alpha.1 is an alpha release for the v4 line. It introduces the Claw mode foundation and Superloop operational foundation while preserving the v3.2.1 hotfix behavior for Workbench API recovery, HChat reloadability, and cross-instance route fallback.
Known Limitations:
- Stability — Expect edge cases and unexpected behavior
- Performance — Not optimized for high-volume usage
- Security — Local-only deployment recommended; API Gateway has no auth
- Platform Support — Tested on Windows and Linux; macOS support is experimental
Best Practices:
- Keep backups of
agents.json,secrets.json, andworkspaces/directories - Do not expose API Gateway to public internet without proper authentication
- Test scheduled jobs before relying on them for critical tasks
- Review agent outputs for sensitive information before sharing
Reporting Issues: Report bugs on the GitHub Issues page with:
- Your OS and Python version
- Backend(s) you're using
- Relevant log excerpts
- Steps to reproduce
Release History
v4.0.0-alpha.1 (current alpha release) — Claw Mode And Superloop Foundation (May 2026)
- Claw mode foundation —
claw-cliis available as a scoped backend with provider routing, packaged runtime discovery, checksum-checked manifest metadata, and clearClawBinaryNotFounddiagnostics while release binaries are absent - Live Claw agent validation — momo validated repo-root read/write/edit through
claw-cli / deepseek/deepseek-v4-flash, with runtime audit evidence and workzone routing - Superloop operational foundation —
docs/SUPERLOOP_FUNCTION_CONTRACT.mddefines runnable loop schema, wait/resume policy, HChat reply handling, issue tracking, evidence requirements, and closeout barriers - Release gates expanded — Claw and Superloop checks are now part of
docs/RELEASE_CHECKLIST.md - Alpha limits — packaged
hashi-clawbinaries, Claw Tool Gateway/MCP parity, Claw shell/test execution, and stable unattended Superloop automation remain release-blocking work for later v4 milestones
v3.2.1 — Workbench/HChat/Remote Recovery (May 2026)
- Workbench API self-repair —
/reboothealth-checks the live Workbench API and rebuilds it when the listener exists but/api/healthis unresponsive - HChat reloadability — hot reboot reloads
tools.*, and HChat draft delivery refreshestools.hchat_sendbefore sending so delivery fixes do not require a full HASHI process restart - Cross-instance Hchat protocol transport —
tools/hchat_send.pynow prefers shared-token/protocol/messagedelivery foragent@INSTANCEand only keeps legacy/hchatas fallback, removing the old bearer-only transport mismatch - Cross-instance route fallback —
agent@INSTANCEdelivery tries multiple Workbench host candidates instead of relying on one stale loopback or discovery value - Remote registry self-healing — Hashi Remote repairs stale persisted LAN peer routes when a non-WSL peer moves back to its verified default Remote port, while preserving unique WSL ports for same-host multi-instance safety
- Remote handshake guard — handshake payloads tolerate older/test-created protocol manager objects while still rejecting alias responses from the wrong instance
v3.2.0 — Slim Core, EXP, Browser Routing & Runtime Hardening (May 2026)
- Slim core architecture accepted —
main.pyreduced from a large feature host into a slim process bootstrap/kernel wrapper; hot-reloadable managers now own agent lifecycle, service management, reboot, startup, shutdown, config, backend preflight, skills, and WhatsApp control - Wrapper Agent Mode implemented — agents can run a functional core model and a separate stateless wrapper model for final visible persona/style rewriting
/core,/wrap, and/wrapperconfigure core model, wrapper model/context, and persona/style slots with Telegram inline controls/verbose onshows a labeled wrapper trace with the core raw output, wrapper final output, wrapper status, latency, and fallback reason- Foreground and background responses, listeners, transfer suppression, handoff, project chat, voice replies, and HChat reply summaries use wrapper-visible text where appropriate; active
bridge:hchatsends remain wrapper-bypassed until the delivery-boundary HChat pipeline is implemented - Core prompt memory stores core raw assistant output, while visible transcript, project chat, core transcript, and audit metadata remain separated for debugging and user-facing continuity
/reset CONFIRMpreserves wrapper mode configuration and prompt slots, matching/syspreservation behavior;/wipe CONFIRMremains a hard workspace clear- Final hardening commit
677212bprevents wrapper persona from drifting back into the core model through prompt memory
- Anatta controls added —
/anatta off,/anatta shadow, and/anatta onswitch per-agent live self-assembly mode by updating workspace config and reloading post-turn observers - Audit Agent Mode implemented —
/mode auditand/auditconfigure a core model plus a separate audit model that emits follow-up findings while leaving the core answer unchanged - EXP guidebook corpus imported —
/exp <task>consults context-specific guidebooks underexp/, including playbooks, validators, failure memory, templates, evidence, and training records - Runtime slimming continued — runtime session, workspace, control, remote command, lifecycle, queue processor, and pipeline responsibilities moved out of the main flex runtime file into focused modules
- Per-instance API Gateway ports — API Gateway defaults to
workbench_port + 1, launcher status uses configured ports, and HASHI API health reports gateway ownership/status - Live reboot validation passed — cold restart,
/reboot min,/reboot max, Workbench health, API Gateway health, andpytestall passed on 2026-05-02 - Browser routing dashboard —
/browserand/browser statusshow route availability for headless browser tools, CLI-native browsing, Brave Search, and the logged-in Chrome extension bridge - Hashi Remote file transfer — direct cross-PC file push support for moving artifacts and EXP packages between HASHI instances
- Browser gateway work — local gateway package and tests for browser-facing bridge capabilities
- OLL HASHI Chrome extension integration — extension scaffold and planning for browser bridge workflows
- Private wake-on-LAN tooling — local private WOL helper and tests
- Workzone support — project/workspace zone helpers and test coverage
- Runtime/backend hardening — adapter, scheduler, skill, remote peer, and protocol updates under active validation
v3.1 — Backend Model Upgrade (April 2026)
- Claude Opus 4.7 — newest Claude model added to
claude-clibackend;opusalias updated - GPT-5.5 — newest Codex model added to
codex-clibackend - Codex CLI 0.125.0 — upgraded from 0.116.0
- Effort levels corrected —
xhighis the correct top tier for Codex (was incorrectlyextra_high); Claude gainsxhighandmax; backward-compatible auto-remapping for old configs
v3.0-beta — Self-Improving Agents (April 2026)
- 6 LLM backends — added DeepSeek API (direct) and Ollama (local LLM) alongside existing Claude/Gemini/Codex/OpenRouter
- Habit-based self-improvement — agents learn from
/goodand/badfeedback, with nightly dream reflection and cross-agent habit governance (Phase 4-5) - SafeVoice — voice confirmation before execution, default ON, 3500-char preview
- Cross-instance agent messaging (HChat) — agents communicate across HASHI instances via API routing
- Token audit & cost tracking — precise API usage tracking, CLI estimation, cost analysis
- Agent behavior audit — local-only daily audit report generation
- Remote backend policy — API backends blocked for automated requests, preventing runaway costs
/loopcommand — recurring tasks via natural language skill injection/long.../end— buffer long Telegram messages for single submission/sayTTS — text-to-speech with multiple voice providers- Minato MCP — 8-tier workflow choreography with KASUMI tool delegation
- Obsidian wiki integration — knowledge vault with daily sync and weekly LLM curation
- Hashi Remote — cross-network agent communication (LAN + Tailscale)
- TUI onboarding — guided first-run setup inside terminal UI
- Telegram file sending — agents can send photos, documents, video, audio
- Job transfer — move jobs between agents (same or cross-instance)
- Dream improvements — mtime gate + content hash dedup, legacy transcript handling
- Scheduler hardening — skill timeout increased, failed runs update last_run to prevent loops
v2.1.0 — Nagare Flow System (March 2026)
- Nagare Flow System — multi-agent workflow orchestration engine
- Meta-Workflow — natural language → complete workflow design
- Cross-vendor evaluation — architecturally enforced independent review
- DAG orchestration — topological step ordering with parallel execution
- Debug agent — auto-recovery with 3 retries
- Evaluation KB — self-improving knowledge base
- Crash recovery — atomic state persistence
v2.0.0 — Tool Execution & Platform (March 2026)
- Tool execution layer (11+ tools for API agents)
- Browser automation (Playwright)
- Pack & Go USB deployment (Windows + macOS)
- TUI terminal interface
- Vector memory system
/dreamskill — nightly memory consolidation/memorycommand — surgical memory control- Flex/fixed backend switching
v1.0.0 — Initial Release (March 2026)
- Multi-backend support (Gemini, Claude, Codex, OpenRouter)
- Multi-agent orchestration
- Telegram + WhatsApp + Workbench transports
- Skills system, job scheduler, memory system
- Handoff context recovery
- Multi-language onboarding (9 languages)
License
HASHI is released under the MIT License.
Support & Community
- GitHub Issues: Report bugs and request features
- Discussions: Ask questions and share tips
- Author: Barry Li
Built with Vision. Written by AI. Directed by Human. HASHI — The Bridge to the Future of AI Collaboration.