convez.ai
AgenteAutomaçãoAvançado
Bazza1982

HASHI - Orquestração Universal de Agentes IA

Bazza1982/HASHI

Controle múltiplos LLMs localmente sem compartilhar tokens

Ver no GitHub
InicialPluginScore · de 0 a 100

Plataforma 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/HASHI

1 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

Estrelas
1
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 1 dia
Versão
v2.0.0
Issues abertas
11
Contribuidores
3

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-cli backend, 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: see docs/ROADMAP.md · Nagare Docs: see docs/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 /good and /bad feedback, 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:

  1. No Token Storage — Uses CLI backends with local authentication, not stored tokens
  2. 7 Backend Adapters — Claude CLI, Gemini CLI, Codex CLI, OpenRouter API, DeepSeek API, Ollama (local LLM), and Claw CLI
  3. Multi-Agent, Single Interface — Chat with multiple specialized agents through one account
  4. Nagare Flow System — Describe a task in natural language; Nagare designs, executes, and improves a multi-agent workflow automatically
  5. Self-Improving Agents — Habit system with /good and /bad feedback, nightly dream reflection, and cross-agent habit governance
  6. SafeVoice — Voice messages are transcribed and shown for confirmation before execution, preventing accidental commands
  7. Context Recovery — /handoff command instantly restores project context after compression
  8. 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
  9. Flex/Fixed Mode Switching — Agents can switch between CLI backends and API backends mid-conversation via /backend
  10. 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
  11. Anatta Live Self-Assembly — Optional per-agent mode (off, shadow, on) that can observe or inject transient self-state guidance while keeping agent.md as the stable identity
  12. Cross-Instance Messaging — Agents across different HASHI instances can communicate via HChat and Hashi Remote
  13. EXP Guidebooks — /exp lets agents consult context-specific operational playbooks, failure memory, validators, and training evidence before acting
  14. Browser Route Dashboard — /browser selects the right internet path: HASHI headless browser, CLI-native browsing, Brave Search, or the logged-in Chrome extension bridge
  15. Hashi Remote File Transfer — move release artifacts, EXP packs, and other files directly between HASHI instances
  16. Audit Agent Mode — run a core model plus a separate auditor that emits follow-up findings without rewriting the core answer
  17. Pack & Go — Build a self-contained USB for Windows or macOS; recipients just plug in and double-click
  18. Vibe-Coded — Every line written by AI, reviewed by AI, directed by human vision
  19. Claw Mode Foundation — claw-cli can run as a scoped backend with provider routing, packaged runtime discovery, checksum-checked manifest metadata, and repo workzone read/write/edit validation
  20. 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, /browser route 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/max effort 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, /dream skill

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: /exp adds context-specific guidebooks with playbooks, validators, failure memory, templates, evidence, and training runs for repeatable high-skill work.
  • From browser automation to browser routing: /browser exposes 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 min can 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 good and /skill bad signals 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


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:

  1. Language selection — 9 languages
  2. AI Ethics & Human Well-being disclaimer — Enter to confirm
  3. Mental health & AI relationship reminder — Enter to confirm
  4. API key check — auto-detects OpenRouter or DeepSeek key with live ping; prompts for a key if none found
  5. Generates agents.json from sample if not present
  6. Bridge starts — TUI transitions seamlessly into normal chat
  7. 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_token in secrets.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

WhatsApp

  • Uses whatsapp-web.js library
  • 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.
  • /api controls the API Gateway from Telegram with inline buttons: status, on, off, and default-model selection.
  • If global.api_gateway_port is omitted, HASHI derives it as workbench_port + 1.
  • Common local layout: HASHI1 18800/18801, HASHI2 18802/18803, HASHI9 18819/18820.
  • GET /api/health reports 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.
  • /restart asks WATCHTOWER to 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

  • name means local-instance delivery only
  • name@INSTANCE means 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 /hchat or /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

CommandDescription
/newStart a fresh CLI session
/freshStart a clean API context without deleting saved memories
/stopCancel current processing
/reboot [min|max|#]Hot restart agents
/restartHard restart this HASHI instance through WatchTower supervision
/status [full]Show agent status, backend info
/handoffRestore continuity from recent transcript
/skillBrowse and run skills (inline keyboard)
/exp <task>Run a task after consulting context-specific EXP guidebooks
/helpShow available commands

Session & Mode Commands

CommandDescription
/mode [fixed|flex|wrapper]Switch between fixed CLI session, flex multi-backend mode, and wrapper mode
/backend [engine]Switch backend (flex mode only)
/modelView/change active model
/coreView/change wrapper-mode functional core backend/model
/wrapView/change wrapper-mode persona wrapper backend/model/context
/wrapperView/edit wrapper-mode persona/style slots
/anatta [status|off|shadow|on]Inspect or switch Anatta live self-assembly mode for the current agent
/effortView/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
/retryResend last response or re-run last prompt
/long ... /endBuffer long text across multiple messages, submit as one
/loop <interval> <task>Create recurring automated tasks via skill injection

Toggles & Settings

CommandDescription
/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
/sayRead 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

CommandDescription
/start [all|<name>]Start a stopped agent
/terminateShut down agent gracefully
/jobsShow 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

TypeBehaviorExample
ActionOne-shot execution, runs a scriptdream, agent_audit, system_status
PromptRoutes user input to a backend/toolcodex, gemini, claude
ToggleInjects instructions while activeTTS, carbon-accounting, academic-writing

Built-in Skills

SkillTypeDescription
dreamActionNightly memory consolidation + behavioral reflection
good / badActionHabit feedback signals
habitsActionHabit governance dashboard and approval surface
agent_auditActionLocal-only agent behavior audit report
cronActionCron job management
heartbeatActionHeartbeat job management
recallToggleAuto-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

BackendEngine IDRequirementsNotes
Gemini CLIgemini-cligemini CLI installedLocal auth
Claude Codeclaude-cliclaude CLI installedLocal auth
Codex CLIcodex-clicodex CLI installedLocal auth
Grok CLIgrok-cligrok CLI installed and logged inLocal auth, streaming JSON
OpenRouter APIopenrouter-apiAPI key in secrets.jsonMulti-model access
DeepSeek APIdeepseek-apiAPI key in secrets.jsonDirect API, cost-effective
Ollamaollama-apiOllama installed locallyFree, 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-free thought/end empty 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:

ToolDescription
bashRun shell commands (sandboxed, timeout + blocklist controls)
file_readRead files with offset/limit pagination
file_writeWrite/create files
file_listList directories with glob filter
apply_patchApply unified diff patches
process_listList running processes
process_killSend signals to processes
telegram_sendSend Telegram messages
telegram_send_fileSend files via Telegram (photos, documents, video, audio)
http_requestArbitrary HTTP requests for external APIs
web_searchBrave Search API integration
web_fetchFetch any URL as Markdown
browser_screenshotNavigate to URL and capture screenshot
browser_get_textExtract visible text from rendered page
browser_click / browser_fill / browser_type_textInteract with web elements (type_text uses CDP for React/contenteditable editors)
desktop_screenshotCapture Linux virtual desktop (Xvfb/XRDP) as base64 PNG
desktop_clickClick at (x, y) on the virtual desktop
desktop_typeType text into focused window (all chars via xdotool)
desktop_keyPress key combos: ctrl+s, alt+F4, Return, etc.
desktop_mouse_moveMove mouse to absolute coordinates
desktop_scrollScroll mouse wheel in any direction
desktop_infoQuery display info and current mouse position
windows_screenshotCapture the real Windows desktop as base64 PNG
windows_click / windows_typeInteract with the real Windows desktop
windows_key / windows_mouse_move / windows_scrollSend Windows desktop input
windows_infoQuery Windows-side mouse / display / window info
windows_window_list / windows_window_focus / windows_window_closeEnumerate 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_* and windows_* 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:

RouteUse
1HASHI standalone/headless browser tools for public or JavaScript-heavy pages
2CLI backend native browsing/search where supported by Codex CLI, Claude CLI, or Gemini CLI
3HASHI Brave Search (web_search) plus public page fetching (web_fetch)
4HASHI 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:

  1. Use windows_info and inspect displays.
  2. Capture windows_screenshot(display=N) for the monitor that should contain the real Chrome window.
  3. Use windows_window_list to find the real Chrome window.
  4. Use windows_window_focus on that window.
  5. Re-capture windows_screenshot(display=N) before typing if focus matters.
  6. Drive navigation with:
    • windows_key → ctrl+l
    • windows_type → target URL
    • windows_key → ENTER
  7. 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(...)
  8. On real pages, verify:
    • active_tab
    • get_text
    • screenshot

What the installed Windows extension is confirmed to do:

  • active_tab
  • get_text
  • get_html
  • screenshot
  • click
  • fill
  • evaluate

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 Tab 11 times
    • press Enter
  • this was the sequence that moved the live bridge from:
    • unsupported action: fill
    • unsupported action: evaluate to:
    • real fill, click, and evaluate execution
  • evaluate is now known-good when executed in the page main world:
    • evaluate('document.title') returned Wikipedia
    • evaluate('JSON.stringify({title: document.title})') returned serialized JSON
  • fill successfully wrote OpenAI into the Wikipedia search input
  • click('button[type="submit"]') triggered real navigation to Wikipedia search results

Known caveats:

  • chrome:// pages are often non-scriptable, so get_text can fail there by design.
  • screenshot can 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

  1. Automatic storage — relevant conversation turns are embedded and saved to bridge_memory.sqlite
  2. Vectorized search — text embedded using BGE-M3 (local ONNX) when available, falling back to hash-based similarity
  3. Context assembly — top-K similar memories retrieved via cosine similarity and injected into prompts
  4. Memory control — /memory command 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 usage data from API responses
  • CLI backends — estimate based on message content + system prompt + context
  • Audit log — token_usage.jsonl with per-turn breakdown
  • Analysis script — scripts/token_audit.py for usage reports and cost analysis

Nagare Flow System

Nagare (流れ) is HASHI's multi-agent workflow orchestration engine.

Key Capabilities:

CapabilityHow It Works
Meta-WorkflowDescribe a task in natural language → Nagare designs a complete workflow
Cross-Vendor EvaluationClaude writes → GPT reviews. No model evaluates its own output
Pre-Flight SystemAll human decisions collected upfront; workflow runs uninterrupted
DAG OrchestrationSteps execute in dependency order with parallel execution
Debug AgentAuto-recovers from failures (3 attempts) before human escalation
Evaluation KBEvery run feeds lessons back — workflows improve over time
Crash RecoveryAtomic 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.json and 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/handshake and /protocol/message with hashi-shared-hmac-v1 when a shared token is configured
  • Missing shared token starts Remote in discovery-only mode: 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 derived live_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.json or remote_live_endpoints.json route points at an obsolete Remote port. Existing healthy peers are left untouched; existing offline/handshake_timed_out peers 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.1 loopback with unique Remote ports
  • Cross-host peers avoid loopback and prefer LAN/Tailscale/configured hosts
  • /protocol/status reports same-host Remote port conflicts through route_diagnostics
  • Remote does not blindly assume all peers use 8766. The 8766 fallback 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@instance addresses 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_TOKEN or secrets.json key hashi_remote_shared_token
  • Public /health, /peers, and /protocol/status responses 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 directory
  • GET /protocol/status — full protocol state: handshake states, in-flight count, local network profile, agent snapshot
  • GET /health — instance info and peer summary
  • /remote list should agree with /peers: a peer that is reachable by hchat but still shown offline in /remote list means 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 capability message_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

LogLocationContents
Bridge loglogs/bridge.logOrchestrator events, backend checks, agent state
Session errorslogs/<session>/errors.logPer-session error details
Launch loglogs/bridge_launch.logStartup sequence
Token auditlogs/token_usage.jsonlToken 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_token in secrets.json
  • Verify authorized_id matches 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.log for 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, and workspaces/ 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-cli is available as a scoped backend with provider routing, packaged runtime discovery, checksum-checked manifest metadata, and clear ClawBinaryNotFound diagnostics 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.md defines 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-claw binaries, 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 — /reboot health-checks the live Workbench API and rebuilds it when the listener exists but /api/health is unresponsive
  • HChat reloadability — hot reboot reloads tools.*, and HChat draft delivery refreshes tools.hchat_send before sending so delivery fixes do not require a full HASHI process restart
  • Cross-instance Hchat protocol transport — tools/hchat_send.py now prefers shared-token /protocol/message delivery for agent@INSTANCE and only keeps legacy /hchat as fallback, removing the old bearer-only transport mismatch
  • Cross-instance route fallback — agent@INSTANCE delivery 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.py reduced 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 /wrapper configure core model, wrapper model/context, and persona/style slots with Telegram inline controls
    • /verbose on shows 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:hchat sends 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 CONFIRM preserves wrapper mode configuration and prompt slots, matching /sys preservation behavior; /wipe CONFIRM remains a hard workspace clear
    • Final hardening commit 677212b prevents wrapper persona from drifting back into the core model through prompt memory
  • Anatta controls added — /anatta off, /anatta shadow, and /anatta on switch per-agent live self-assembly mode by updating workspace config and reloading post-turn observers
  • Audit Agent Mode implemented — /mode audit and /audit configure 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 under exp/, 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, and pytest all passed on 2026-05-02
  • Browser routing dashboard — /browser and /browser status show 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-cli backend; opus alias updated
  • GPT-5.5 — newest Codex model added to codex-cli backend
  • Codex CLI 0.125.0 — upgraded from 0.116.0
  • Effort levels corrected — xhigh is the correct top tier for Codex (was incorrectly extra_high); Claude gains xhigh and max; 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 /good and /bad feedback, 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
  • /loop command — recurring tasks via natural language skill injection
  • /long ... /end — buffer long Telegram messages for single submission
  • /say TTS — 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
  • /dream skill — nightly memory consolidation
  • /memory command — 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


Built with Vision. Written by AI. Directed by Human. HASHI — The Bridge to the Future of AI Collaboration.

Ver o original no GitHub

Bom para

Relacionados