What is Haicue? Run your agents. Keep the work together. A workspace around your agents Haicue is a desktop app for working with AI agents across projects, conversations, and days. It launches agent sessions, keeps context and results in folders called threads, and gives you a place to review what happened and decide what comes next. Your agent still does the reasoning and uses its own tools. Haicue handles the surrounding work: sessions, shared files, schedules, live context, and follow-up. Where Haicue fits In technical terms, Haicue can be described as a meta-harness: a workspace around agent harnesses. An agent harness runs a model with tools and a conversation. Haicue sits around supported harnesses, such as Claude Code and Codex, and manages their sessions together. The distinction matters when you choose a model, connect a tool, or set permissions. Those capabilities still depend on the agent you are running. Haicue adds a common place for the work around them. Agents can operate Haicue too You can ask an agent to organize and run the work around a task. Through Haicue’s skills and hai commands, it can inspect and reorganize threads while preserving their sessions, launch sessions with a chosen agent and model, send them instructions, manage automations, and open tools such as Cues and LiveApps. For example: “Start a review session on the onboarding thread, give it the brief, and bring its findings back here.” For work across several threads, use the Index thread as the place to coordinate. Three things to know Thread The lasting home for a piece of work. It holds instructions, source material, results, and loose ends. Session A conversation with a running agent. A thread can have several sessions, including sessions from different agents. Cockpit The view where you work on a thread: chat, files, sessions, and tools together. A session can end without ending the work. A new session can read the thread and continue from the recorded decisions. Choose a starting point Start your first thread for a complete first-use walkthrough. Manage sessions if you already have work running. Use the command line to let an agent operate the workspace. Install and set up Install Haicue, connect an agent, and choose where your work lives. Choose your platform The install page has downloads for macOS on Apple silicon and Windows x64. Windows support is experimental. On macOS, open the disk image and drag Haicue into Applications, or use the Terminal or Homebrew instructions. On Windows, run the downloaded installer and follow its prompts. Depending on your system configuration, Haicue may require administrator privileges on macOS or Windows. What you need Have an agent runtime installed and signed in before starting a session. Haicue uses the runtime’s account and available models; installation does not include an agent subscription. Choose a writable workspace folder for your threads and files. A Git repository is optional. First launch Open Haicue and follow setup to choose your workspace and connect your agent. Start with one small task using Start your first thread . Enable optional tools in Settings as you need them. Live Capture and browser tools may need additional setup and operating-system permissions. If setup gets stuck If a session can run, ask its agent to troubleshoot Haicue. Otherwise, check that the agent runtime is installed and signed in, and look for a startup trust or permission prompt. See Troubleshooting or email hai@haicue.com with what happened. Start your first thread Take one task from a first prompt to a result you can return to. Before you start Install and open Haicue, then complete its setup. Choose a workspace folder and connect an installed, signed-in agent. Haicue uses that agent’s account and available models; installing Haicue does not include an agent subscription. Use a small real task, such as reviewing a design or preparing a meeting note. A Git repository is optional. 1. Give the work a home In Browse, use the thread creation control and describe the work. Review the proposed name, location, and context before creating it. Open the thread to enter its Cockpit. For example: “Create a thread for planning our onboarding changes. Keep decisions and open questions together.” 2. Start a session Choose New session in the thread. Pick an available agent and, where supported, a model and effort level. Wait for the session to finish starting, and answer any sign-in or trust prompt it presents. 3. Add context and ask for a result Put source material in the thread’s in/ folder, or attach the relevant files to your prompt. Tell the agent what you need and where the result should go. Read the notes in in/. Identify the three biggest onboarding problems. Write a proposed plan in out/onboarding-plan.md. Record any questions that need my decision as Awaiting items. Review the result in the thread’s files. Ask for changes in the same session. 4. Leave a useful stopping point Before you leave, ask the agent to record the decisions, remaining work, and next step in the thread. When you return, open the thread and select the previous session, or start a new one and ask it to read the context and saved result. You have finished this walkthrough when you can find the result and explain the next step without rereading the whole chat. Manage sessions Start, resume, and move between agent conversations without losing where the work belongs. Start and select Open a thread and choose New session . Choose the agent, model, and effort options available for that runtime. The new session appears in the thread’s session tabs. Select a tab before sending a prompt. Each session has its own conversation. Switching tabs changes which agent receives your input. Return to a conversation Use the session picker to find sessions associated with the thread. Select a live session to continue it. A closed session can be resumed through its original agent when that runtime and its saved conversation are available. Reading historical output is different from having a live agent ready to receive input. Check the selected session’s state before sending work. Move work to another thread A session has one current thread and can retain history in other threads. A session shown as moved belongs elsewhere now; follow its destination to continue there. Stay pins the selected session to the current thread. Follow accepts the destination thread. Opening or reading another thread’s files alone is not a request to move the session. Close with intent Use the session’s close control when you want to end its running agent. Closing a session does not delete the thread’s files. Keep the next step in those files so the work can continue even if the conversation cannot be resumed. From an agent or terminal hai list sessions hai list sessions --all hai session inspect hai session open projects/onboarding --agent claude --label review projects/onboarding is an example thread key. Replace it with an existing thread. Commands that infer the caller work from a managed Haicue session; outside one, supply the session ID where required. Everyday session tools See Working in a session for file previews, prompt improvement, activity chips, attachments, and stashed drafts. Working in a session Read files, refine a prompt, follow running work, and keep useful drafts close at hand. Preview files without leaving the thread Open Files in the thread sidebar and select a file. Markdown opens as a formatted document; supported text and images open in the file pane. Use the single-tab quick-preview mode to browse several files in the same tab, or switch to multiple tabs to keep them open. For editable text files, choose Edit to work on the source, then Preview to read it again. Large files may have a limited, read-only preview; unsupported formats show a no-preview message. Ask about a passage in a document Select text in a rendered Markdown preview and choose talk to agent . Write your question or requested change in the dialog, then send it to the selected live session. Haicue includes the file reference and selected passage with your message, so you can ask “Does this still match the implementation?” without copying the passage into a separate prompt. Find text inside an open file Use the search control in the file pane to find text in the open document. This is useful when checking a long note, configuration file, or source file. Use the sidebar’s file search when you need to find a different file. Insert a file, skill, or command Type : in the prompt to search for workspace files and directories. Type / to see available skills and agent commands. Suggestions depend on the selected agent and the available workspace. Use the arrow keys to move through suggestions, then Tab or Enter to insert one. Escape dismisses the list. Selecting a suggestion adds it to your draft; it does not send the prompt. Improve a prompt before sending Write a draft, then press Command on its own while the input is focused to reveal Improve. Select Improve to have Haicue refine the draft using the session and thread context. This gesture is shown here on macOS. The original is saved in your session’s stashes. The improved prompt returns to the input for you to review and edit before sending. While improvement is running, the same control lets you cancel. A sample draft with the Improve control visible. Follow work through activity chips During a turn, chips such as Ran, Explored, and Edit show the agent’s recorded actions. Hover over a chip, or focus it with the keyboard, to see the available details. Depending on the action, this can include a command, output, a file path, or a change. Use these details to follow a particular step without leaving the conversation. For searching recorded activity across sessions and threads, open Track . Paste images and attach files Paste an image into the input, drag in a file, or select the + button to choose files. Attachments appear beside the draft; image attachments have a preview. Remove an attachment with its × button before sending if it is no longer needed. Add a sentence explaining what the agent should do with the attachment—for example, “Compare this screenshot with the page and fix the spacing.” Large pasted text can be staged as a text attachment instead of filling the input. An image and a Markdown brief attached to a sample prompt. Stash a draft and return to it With a draft in the input, use the Stash input shortcut—Command-S by default on macOS—to save it and clear the input. Each session keeps up to three stashes, with the newest first. Hover over the numbered stash controls to preview them, then select one to restore it into the input. Restoring removes it from the stash list and replaces the current draft, so stash that draft first if you want to keep both. With an empty input, the stash shortcut restores the most recent stash. These are prompt drafts, separate from Git stashes. The shortcut can be changed in Settings. Numbered stashes with previews of two saved sample drafts. Keep context across sessions Write down what the next session needs, close to the work it describes. Use a thread for lasting context A thread is a directory in your workspace. Keep its purpose and standing instructions in context.md , source material in in/ , and results in out/ . onboarding/ context.md in/ interview-notes.md out/ proposed-changes.md The folder can hold other files your work needs. It does not have to be a code project. Write instructions that survive a handoff Use context.md for the goal, constraints, important references, and working conventions. Keep current decisions and next steps in a clearly named note. Ask the agent to update these when the plan changes. Before you finish, record what changed, what is still unresolved, and the next step. Include the paths of the files a new session should read. Layer broad and specific instructions A parent thread can describe the wider project; a child thread can hold one narrower task. The thread skill reads ancestor context from broad to specific, then the current thread’s context. Keep instructions at the level where they apply. A shape describes a folder structure you want to reuse. A loop describes how to work through a repeatable process. Neither is the conversation itself. Coordinate across threads When the work spans several threads, keep priorities and cross-thread decisions in the Index thread . An agent working there can inspect the other threads, start or contact their sessions, and bring the results together. Keep detailed source material and outputs in the threads that own the work. Reorganize without losing sessions As work grows, ask an agent to rename or move threads into a structure that fits. Haicue’s thread-move operation preserves session associations and updates stored references to the moved threads. You can coordinate these changes from the Index thread . Understand the boundary Two sessions on a thread can read the same files. They do not automatically share every message, tool result, or private reasoning step. Ask a new session to read the relevant files, and give it a specific handoff. The context meter describes the agent conversation, not the amount of material stored in the thread. Saving a file preserves it; the next agent still needs to read it. Inspect before acting hai thread.inspect projects/onboarding hai thread switch projects/onboarding thread.inspect reads the thread’s context and state. thread switch changes the calling session’s current thread and clears its Stay pin. Use the second command only when moving the work. Coordinate from Index thread Keep the overview in one thread and let focused sessions carry out the work. Give coordination a home The Index thread is the place to coordinate work across threads. Keep your priorities, links to active work, and decisions that span projects there. Start a session in the Index thread when you want to ask what needs attention or delegate work without entering each thread yourself. Ask the agent which threads to review and what to bring back. It builds the overview from their context, saved results, and session state. Set the scope Open the Index thread. In its context.md , name the threads it covers, your priorities, and how you want work delegated and reported. Keep a short overview in the thread, with links to the detailed plans and results in each working thread. Start a session and ask it to review that scope before proposing the next moves. This thread coordinates projects/onboarding and projects/website. Keep priorities and cross-project decisions here. Keep implementation plans and results in their own threads. When delegating, give each session a task, an output path, and a clear stopping condition. Record which session owns each task. Ask for an overview Review the context, recent results, and Awaiting items in the threads listed here. Tell me what changed, what is blocked, and which decisions need me. Save a short overview with links to the supporting files. The agent can discover threads with hai list threads , read their context with hai thread.inspect , and inspect registered sessions. It can stay in the Index thread while reading the others. Reading a thread does not move the coordinating session into it. Ask it to distinguish saved results from work still in progress. A live session or a recorded status alone does not tell you whether a task is complete. Delegate and steer the work Start a Codex session on projects/onboarding to review the proposed form changes. Have it read the brief and write out/form-review.md. Ask the existing website session for its current blocker. Keep a record here of who owns each task and where results will land. Haicue lets the coordinating agent choose a runtime, label, model, and effort when opening a session, subject to that runtime’s support. It can then send instructions or follow-up questions to a specific session. Newly opened sessions retain a link to the session that launched them. Give the receiving session the relevant context and expected result. Ask it to save its findings and report back to the coordinator. Sessions retain separate conversations, so make the handoff explicit. See Work with multiple agents for session commands and how to avoid overlapping edits. Reorganize threads as work changes Ask the agent in the Index thread to rename threads or move them into a clearer structure while keeping their sessions intact. Haicue’s thread-move command updates the stored thread references and session associations along with the folders, so existing sessions remain connected to the work. Group the onboarding and website threads under a product category. Show me the proposed structure first, then use Haicue’s thread-move command to apply it while preserving the existing sessions. The agent can preview a move plan before applying it. Use that supported operation when reorganizing threads so the folder moves and Haicue’s records stay together. Let the agent arrange the workspace The same session can operate other parts of Haicue as the task calls for them: create or update an automation, record an Awaiting item, show findings in Cues, attach a local app, or build a reusable skill. Set up a weekday review of these threads at 9:00 America/Vancouver. Have it update the overview and flag decisions that need me. Show me the automation definition before saving it. This is how the Index thread becomes useful beyond a list of links. The agent can organize the next steps and use Haicue to carry them out. Each feature still has its own setup and controls; a coordination session does not enable add-ons or grant service access by itself. Return without depending on one session Before ending the coordinating session, save the priorities, outstanding delegations, session IDs, and result paths in the Index thread. A later session can read that record, inspect the current state, and continue. The Index thread keeps the overview. The working threads keep the details. Link to a decision or result where it lives so the overview stays short and can be checked. Work with multiple agents Split independent work while keeping ownership and results clear. Several sessions, one piece of work You can open multiple sessions on a thread, using the same agent or different supported agents. For example, one session can implement a change while another reviews the requirements. Give each session a specific task and expected result. “Review the accessibility of this form and write findings in out/accessibility.md” is easier to coordinate than “help with the feature.” Example prompts Describe the work you want to delegate. The agent can use Haicue to organize the threads and sessions around it. Create a thread and start a session Create a thread for reviewing our onboarding flow. Add context with the goal and links to the relevant files, then open a Codex session there. Ask it to review the flow and save its findings in that thread. Split a task between two sessions Open two sessions on the website thread. Have one review the docs for accuracy and the other check navigation and accessibility. Give them separate output files. Bring their findings back here with a recommended order for addressing them. Choose how a session runs Start a Claude Code session on the onboarding thread, label it “design review,” and use an available model suited to a careful review. Give it the brief and ask it to identify gaps before we implement. Steer an existing session Find the session working on the website docs. Tell it to keep the changes local and focus on the getting-started guide first. Ask it to report any missing information before continuing. Give a session a browser check Open a review session on the website thread. Ask it to use the DevTools browser to check the local site on desktop and mobile, try the navigation and forms, and report console or network errors. Have it save screenshots and findings in that thread. Collect the results Check the review sessions we started. Read their saved findings, combine duplicates, and write one action list in this thread. Record any decisions that need me as Awaiting items. Name the destination thread, the task, and the result you expect. For work across several threads, send these requests from the Index thread . Delegate from an agent An agent can use hai session open to launch another session on an existing thread. Haicue records the calling session as its parent. The session picker shows the relationship, and child sessions on other threads can be opened from the parent’s session tab. hai session open projects/onboarding --agent codex --label accessibility hai list sessions Find the new session’s full ID before sending its task: hai session send SESSION_UUID "Review the form accessibility. Save findings in out/accessibility.md." hai session inspect SESSION_UUID Replace SESSION_UUID with the actual ID. Tell the child what to read, what it owns, where to write, and how to report back. Opening a child does not copy the parent’s entire conversation. Configure and drive another session When opening a session, the coordinating agent can choose its runtime, label, model, and effort using --agent , --label , --model , and --effort . Available choices depend on the runtime and account. These are launch options; they do not reconfigure an already-running session. For an existing session, discover its ID, inspect it, and send a specific instruction with hai session send . The same command can deliver a correction, a new constraint, or a request for progress. Ask the recipient to save a result and report back so the coordinating session has something concrete to review. Use the Index thread when this coordination spans projects. A session can also manage Haicue features such as automations, Awaiting, skills, and LiveApps through their supported commands. Avoid overlapping edits Sessions on the same folder share its files. Haicue does not create an isolated Git worktree just because you start another session. Give agents separate files or set up separate worktrees when their changes could collide. Use one session to combine the results and verify the final change. The parent/child relationship helps you navigate the work; it does not guarantee conflict-free edits. Runtime subagents are separate An agent may also use its own subagent tools. Those follow the runtime’s rules. A Haicue child session is a separately managed session with its own thread association and lifecycle. Use Live Capture Let an agent follow a conversation or a selected screen while you work. Start a capture Open the thread and select the session that should receive the context. Open Live Capture and choose Start. Choose microphone, screenshots, or both. For microphone capture, complete voice setup if requested and choose the language. For screenshots, select the screen, window, or region you want to share. Review the selection before starting. Grant the macOS permissions requested for the sources you selected. The transcript and screenshot activity appear in the thread. Haicue supports one active capture at a time. Give the agent a job Follow this meeting. Keep a short list of decisions and unanswered questions. When I stop capture, write the follow-up in out/meeting-notes.md. Capture provides context. Your prompt tells the agent what to do with it. For a few observations you can glance at during the conversation, ask for Cues . Pause, resume, and stop Use Pause when you need a break and Resume to continue. Use Stop when the capture is finished. Check the source indicators to see whether microphone and screenshots are active. Speaker labels distinguish your enrolled voice from other speakers. Treat the transcript as a working record and check names, numbers, and quoted decisions before sharing a summary. What stays local Speech recognition and voice matching run on your machine. Enrollment data and the voiceprint stay local. Transcript text handed to an agent, and screenshots it reads, may be processed by that agent’s provider. Local capture does not make the agent conversation offline. Agent controls hai lc status hai lc pause hai lc resume hai lc stop Screen commands such as hai lc screen snapshot are restricted to the session that owns the capture. An agent can reuse an approved screen target; choosing a new target belongs in the capture controls. Browser control Let an agent use a real browser to understand a page and check its work. Drive Chromium through DevTools Haicue’s browser-control skill drives Chrome, a Chromium-based browser, through the Chrome DevTools Protocol. The agent can navigate pages, interact with forms, inspect the page structure, take screenshots, and examine console errors and network requests. This gives the agent context from the website as it actually runs. It can compare what appears on screen with the intended result and investigate what went wrong. Ask for a browser check Open the local website in the DevTools browser. Walk through the signup form, check the validation messages, and inspect the console and failed network requests. Save screenshots and findings in this thread. Give the agent the URL, the interaction to try, and the result you expect. Say whether it should only report problems or also fix them. Check the docs at http://127.0.0.1:4186/docs on desktop and mobile. Try search, navigation, and copying an example. Report anything that is broken or hard to use, with a screenshot of each problem. Connect the browser Ask the agent to use the Haicue DevTools skill. Its bundled helper connects to a debugging-enabled browser or launches Chrome with a separate debug profile. The debug profile has its own sign-ins. It does not automatically use your everyday browser’s logged-in accounts. If the task needs an account, sign in to the service in that browser. Use the page as evidence The agent can read the page structure to find controls, use screenshots to check the visible result, and inspect network requests or console errors to explain failures. For example, it can distinguish a form that never submits from a request that reaches the server and fails. During skill development, browser inspection can also reveal a repeatable API or command path. The resulting skill can use that path for future work when it is more reliable than driving the page. Browser control or LiveApp? Use browser control for a full browser session, browser-based services, and DevTools investigation. Use a LiveApp to keep a running local app inside the thread, beside the conversation. Both let an agent inspect what it is working on. Choose the surface that fits the task: a browser tab for website work, or a thread tab for an interactive local tool. Review Git and file changes See what changed and give an agent a precise reference to review. Enable Git Turn on Settings → Add-ons → Git , then open Git in the thread’s Toolbox. Haicue finds repositories associated with tracked projects and explicitly added projects, including linked worktrees. If a repository is missing, make sure the project is known to Haicue. Discovery is scoped to those projects. Inspect a repository Select a repository to see changed files, staged and unstaged state, untracked files, conflicts, stashes, and branch divergence. Expand a session commit to inspect its changed files. Use the file context menu to open selected files in a detected editor. Cmd-click on macOS or Ctrl-click elsewhere toggles a file selection; Shift-click selects a range. Refer to a change in chat Use a commit file’s prompt-reference action to insert a reference into the selected session’s draft. Add the question you want the agent to answer. Review this change for a missing error path: git:repository:commit-hash:path/to/file The actual reference is generated from your selected repository, commit, and file. What the view can tell you The Git view is read-only. Use your agent, terminal, or Git client to stage, commit, fetch, or push. Ahead/behind counts reflect the remote refs already on disk; Haicue does not fetch them. “Session commits” means commits dated after the selected session began. It does not prove that the selected agent authored them. Track shows file changes associated with agent activity even outside a Git repository. Use Git for repository history and Track for the files involved in the work. Command line hai git repos projects/onboarding hai git repo projects/onboarding /absolute/path/to/repository Use a repository path returned by the first command. Both commands inspect state without changing the repository. Follow progress with Cues Ask for a few useful observations you can glance at while work continues. Ask for a deck Cues is a set of cards curated by the agent for a particular task. A deck can float beside your work or dock in the Cockpit. Use Cues during this review. Keep one card per finding, with the reason it matters and the evidence. Update the card as it is resolved. For a meeting, ask for decisions, unanswered questions, or points you want to revisit. Live Capture supplies the conversation; Cues selects what is worth noticing. Read without following every step A card can hold a short observation, more detail, and actions. Pin a card when you want to keep it in view. The agent can update the same card as the work develops and settle it when that work is done. Use cards for findings and decisions rather than every tool call. Put the full result in the thread’s files when it needs to survive as a document. Choose the right place Cues Observations to keep in sight during ongoing work. Notifications Completed work, failures, or changes that deserve attention. Awaiting An unresolved expectation with a next move. Chat The conversation and instructions for the selected session. Schedule work Run a task once, at an interval, or at calendar times you choose. Create an automation Enable Settings → Add-ons → Automations . Open Automations in the thread’s Toolbox. Describe the task and when it should run. Review the draft: When, Do, Runs with, Report, and Thread. Save it when the schedule and task are correct. Every weekday at 9:00 in America/Vancouver, review this thread’s open questions and write a short note about what needs my attention. Keep the work description about what one run should do. The schedule belongs in the trigger. Choose who runs it A session automation uses a bound agent session and preserves its model and effort settings. Haicue can resume that session when needed. A Brain automation uses a separate, bounded background runner. Haicue and its host must be available for local scheduled work. Agent authentication and any services the task uses must also be available. For calendar schedules, review the timezone and the policy for missed runs. Review and control runs Select an automation to see its definition and History. Use Run Now to try it, Pause to suspend it, and Resume to enable it again. Run Now is unavailable while the automation is paused or already running. Pausing cancels the active automation occurrence. Do not assume that this also kills an agent process or a command it already started; inspect the session if you need to stop the underlying work. Results and questions The executing agent reports success, retry, needs_user, failed, or skipped. A run that needs your decision should say what is missing. Review the result and any saved files before relying on it. Event activation, automatic session creation, and context rollover are separate optional policies. They are disabled by default. A schedule alone does not enable them. Command line hai automation list hai automation inspect AUTOMATION_ID hai automation run AUTOMATION_ID hai automation pause AUTOMATION_ID hai automation resume AUTOMATION_ID Replace the ID with one returned by the list command. See the command reference for creation and run reporting. Repeat a process with loops Give a recurring kind of work a clear sequence and a definition of done. What a loop does A loop is a written process attached to a thread or category. It names the inputs, phases, checkpoints, and completion conditions. An agent follows it and records how far the work has reached. For example, a review loop might be: read the request, inspect the change, verify behavior, record findings, and resolve each finding. Define and run one Ask the agent to create a loop for a process you repeat. Give it the actual checkpoints and stopping conditions, then review the definition before using it. Define a review loop for this thread: read the brief, inspect the diff, run relevant checks, and save findings. Finish only when each finding has a resolution or a clearly named owner. Once the loop is attached to the thread, ask the agent to run it by name. The bundled thread-loops skill reads the definition and manages its status. Read the status The thread can show the last run, the phase reached, whether work is complete or blocked, and what is blocking it. Recorded status is a handoff, not proof that a check passed. Ask for the supporting result when it matters. Reset a loop when starting a fresh pass. Do not mark an incomplete run complete just to remove it from view. Loop or automation? Use a loop Use an automation “Follow these steps every time we review a change.” “Start this review every Friday at 10.” Defines the process and completion gates. Defines when work runs and how it is executed. An automation can ask an agent to run a loop. A loop on its own is not a timer or background service. Track loose ends with Awaiting Keep a question or commitment visible until it is actually resolved. Record the next move An Awaiting item belongs to a thread. It describes what remains open, whether the next move is yours or someone else’s, and an expected completion date when one is useful. Add an Awaiting item: I need to choose the onboarding approach after reviewing out/proposed-changes.md. The next move is mine. Use a specific decision or expected result. “Waiting for Sam to approve the copy” is more useful than “follow up.” Review and resolve Open the thread’s Awaiting items when you return. Check what changed, update the owner or expected date, and resolve an item with a short explanation when the expectation is met. Mute or snooze an item when it should stop asking for attention for a while. That leaves the loose end open. Resolution means the work or decision is settled. How it differs from a notification A notification tells you something happened. An Awaiting item says something still needs to happen. Reading a notification does not resolve the underlying item. A loop can produce Awaiting items at its checkpoints, and an automation can review them later. Each still has a separate purpose. Agent example hai await projects/onboarding '{"id":"choose-approach","op":"set","item":{"desc":"Choose the onboarding approach","direction":"mine","where":"self","status":"open"}}' Reuse the same item ID when updating it. The set operation replaces that item, so retain the details you want to keep. Resolve with status: "resolved" and a resolution_details explanation. Use the Awaiting skill for ordinary updates. Connect tools with skills Give an agent a repeatable way to read information or take an action. Use an installed skill A skill combines instructions with the scripts or tools needed for a task. Haicue includes skills for operating its own workspace. Other skills can connect an agent to a service, a browser, or local software. Ask the agent which skills are available, or inspect the custom-skill list. Access depends on the skill’s implementation and the accounts you have connected. hai list skills hai skill inspect SKILL_ID Create a custom skill Enable Settings → Add-ons → Skill Designer . Describe what the skill should do and how it will connect. In Shape, separate Find & read capabilities from Take action capabilities. Build the manifest, then start the Build session to implement and verify it. Install it for the agents you want to use after the connection, read, and action checks pass. For example: a skill could read your issue tracker, find unresolved tickets for a project, and create a ticket when you explicitly ask. A definition is not a working connection Building the manifest creates the skill’s instructions and declared tools. The implementation session still needs to build the connection, handle authentication, and verify the behavior. Installation is a separate step. Keep credentials in the skill’s local credential setup, not in its instructions or shared thread notes. Document the required credential names and setup steps. Use APIs, local commands, or the browser A skill can use an API key, OAuth, Chrome DevTools discovery, custom setup, or no external connection. Prefer a repeatable API or command when one exists. Browser inspection can help discover how a service works or handle a browser-only task. Third-party tools remain responsible for their own permissions and service access. A skill installed for one agent does not mean every other runtime can use it unchanged. Drive a browser with DevTools Agents can drive Chrome through the Chrome DevTools Protocol to inspect a website, diagnose errors, or discover how a web service works. See Browser control for the workflow and example prompts. Add a visual tool A skill can include a local web app for interacting with its results. Use LiveApps to open that app inside the thread and let the agent inspect it. Open a local app in a thread Keep a working web app next to the conversation that is building or using it. Attach a running app Start the app’s local development server, then ask the agent to attach its address to the current thread. The server must use a loopback HTTP address such as http://127.0.0.1:3000 . hai web-connector attach http://127.0.0.1:3000 --name preview hai web-connector list Haicue opens a LiveApp tab. It displays the real running app, including development-server reloads. Inspect what is on screen The Web Connector skill lets the agent inspect the page’s DOM, console errors, network activity, and observed assets. Give it a concrete check: Open the preview, submit the empty form, and check that each required field has a visible error. Inspect the console for errors. Agents can also listen for selected events and exchange messages with apps that support that interaction. Inspection is scoped to the attached app; it is not full access to every browser tab. Recover a stopped preview If the local server stops, restart it. The connector can recover when the upstream returns. Agents can reload the preview or reattach a failed connector without creating another tab. hai web-connector reload CONNECTOR_ID hai web-connector reattach CONNECTOR_ID Close and restart Closing the tab stops its connector. The upstream app server is separate; the agent that started it can stop it when it is no longer needed. LiveApp tabs are runtime state and need to be attached again after Haicue restarts. Use Chrome DevTools when a task needs an existing browser login, cookies, or detailed browser performance tools. Use Chromium and DevTools for browser work Use Browser control when you need a full Chrome session, an existing debug-browser login, or DevTools inspection. LiveApps keeps a local app inside the thread; browser control lets the agent work directly with a Chromium-based browser. Security and audit Review observed agent activity and set rules for file and network access. Enable protection The Security Module is an optional add-on, disabled by default. Enable it in Settings, then use Security Center to configure file and network protection separately. Protection applies to agents launched through Haicue. Launch a new session after enabling or changing the policy: an existing process keeps the file protection it started with. Set access rules Rules can allow access, ask you, or deny it for a file path or network destination. An explicit deny takes precedence. Blacklist mode allows unmatched activity; whitelist mode asks about unmatched observations. File protection is available on macOS. Its whitelist mode keeps baseline access needed by the agent and local tools, including access within the home directory. It is not a blanket block on every unlisted file. Linux supports network protection, but not file protection. Review a question When a policy question appears, inspect the session, operation, and requested resource before choosing a response. Depending on the request, you can allow it once, for the session, or persistently, or deny it. A macOS file denial has already been enforced by the operating system. An exact persistent allow takes effect on the next agent launch; allowing that question cannot retroactively complete the blocked operation. Read the audit history Use Security Center’s history to review observed requests and decisions. Entries record the agent, session, thread at the time, source, and observation coverage. This helps you connect a request to the work that caused it. Coverage is partial. Network history records traffic seen by the proxy. HTTPS observations identify the destination domain and port, not the encrypted URL path. Allowed file reads and writes are not listed; concrete denied attempts can be reported when macOS log access is available. Use file tracking to review captured changes to files. Security history answers access-policy questions; Track helps explain what changed. Track activity Find recorded file changes, commands, prompts, and agent replies across threads and sessions. Open Track Open a thread’s Cockpit and select Track in the Toolbox. Review captured file edits, commands and their output, and conversation transcripts without searching the entire chat. Track works with agent activity even when the files are not in a Git repository. Choose an activity type Edits Captured file changes, grouped by time, with added and removed line counts. Expand a file to inspect its changes. Run Recorded commands. Expand an entry to read the command and its captured output. Transcript User prompts and agent replies. Search for a phrase and expand a matching entry to read it. Subagents and Misc Additional recorded agent activity. Use the search field to filter by filename or content. Combine activity filters when you want to see related work together. Choose the scope Chat History Activity associated with the visible chat range. Thread Activity for the current thread. Session Activity for the selected session. Global Activity across tracked threads and sessions. Use the activity filters and time grouping to narrow the view. Start with Session when checking one agent’s work, or Thread when several sessions contributed. Inspect and follow up Expand a file to inspect its recorded changes. Compare the before and after text, then copy the relevant change when you want to ask the agent about it. Explain why you changed this file. Check whether the change matches the brief, and identify any related behavior that still needs testing. Keep the relevant path or copied change with the question so the agent can check the same evidence you are looking at. Track, Git, or Security? Track shows recorded edits, commands, prompts, and replies associated with agent work. Git shows repository state and commit history. Security shows observed access requests and policy decisions. Track is not a complete operating-system audit or a backup of every file version. Use it to understand recorded work, and use Git when you need the repository’s history and current change state. Access work from your phone Check results and direct sessions on your running desktop host. Connect to your computer Sign in to Haicue on your computer. Enable Settings → Add-ons → Mobile Remote . Open haicue.com/remote on your phone and sign in with the same account. Select your available computer. No separate connection code is required. Keep the desktop host awake, connected, and running Haicue. Continue the work Threads Browse registered threads and start a session on the work you choose. Sessions Read recent output, send instructions, close a live session, or restore a previous one. Awaitings Review open loose ends and resolve or delete an item. LiveApps Open a currently attached local app through the connection to your desktop host. For example, open a session that has finished a review, read its findings, and send the next instruction from your phone. Understand the connection The work still runs on your desktop. Mobile Remote relays requests to that host; it does not move the session to a cloud computer. A LiveApp also needs its local server and connector to remain available. The mobile browser and desktop must use the same account. Turning off Mobile Remote from desktop or mobile closes the host connection and removes it from discovery. If no computer appears Check that the desktop app is running, Mobile Remote is enabled, and both devices are signed in to the same account. Confirm that the host has a network connection, then choose Check again on the mobile page. Command-line reference The complete hai command reference, grouped by what you want to inspect or control. Using this reference Run hai from a Haicue-managed agent session. Most commands require the running desktop engine. Use the IDs returned by discovery commands. This page lists the implemented command surface; run hai help to check your installed version. hai help hai --help hai version hai --version In the syntax below, is required, [value] is optional, and a|b means choose one. Replace placeholders and omit the brackets; these are command signatures, not scripts to run as a batch. Quote text and JSON so the shell passes them as one argument. Definition inputs accept a YAML or JSON file path, quoted inline data, or - to read standard input where shown. Discover sessions and threads Inspect the calling session and discover registered sessions, threads, and skills. Add --all to include closed sessions. hai whoami hai list hai list sessions [--all] hai list threads hai list skills hai list all [--all] Sessions Open, inspect, focus, send input to, or close a registered session. Opening creates a fresh session. Closing terminates its pane. hai session open [--agent claude|codex] [--label