Ari’s Space*   est. 2026
Skip to content
ari*s space[ a. ]
← Libraryari os / 2026-06-15

Using ARI-OS day to day

The commands, skills, Cortex MCP tools, and the dispatch and monitor surface you drive every day.

8 parts / Hover to explore. Click to read.

The commands, skills, Cortex MCP tools, and the dispatch and monitor surface you drive every day.

Main session: outcome + limits
             | brief
             v
         one worker
             | returned artefact
             v
       inspect evidence
             |
       accept or correct
A command or completion report starts the check; it does not complete it. The inspected dispatch read-only flag disables named tools, not every possible filesystem write.
Context Pack (for agents)

Keep your main session available for the outcome, constraints and decisions. Give workers bounded jobs, then inspect what they return.

This page keeps the command reference from the original June 2026 guide, with corrections checked against the public source. The overview explains the working model; the install guide covers setup and version boundaries.

Use the ten session commands

The slash commands are entry points inside the main conversation. Choose the one that matches the next piece of work.

  • /brainstormcommandOpen a structured brainstorm that pulls intent and requirements out before any code is written.
  • /dispatchcommandHand a brief to a background worker and keep working in your own session.
  • /dreamcommandRun a memory consolidation pass, distilling raw capture into durable signal.
  • /handoffcommandWrite a clean handoff document so the next session can pick up where you left off.
  • /monitorcommandOpen the live monitor to watch every running worker in one place.
  • /morningcommandRun the morning briefing: a maintenance check and a dashboard of what is in flight.
  • /nightcommandClose the day out with an end-of-day review layered on top of a consolidation pass.
  • /prefetchcommandWarm the Cortex ahead of a task so the right context is loaded before you ask.
  • /recallcommandPull the most relevant past context for a query straight into the conversation.
  • /remembercommandSave a fact, a decision, or a piece of thinking to the memory layer.

A command name doesn't prove the action succeeded. Read its result and check the artefact or state it was meant to produce.

Keep the skills distinct from the commands

Skills describe working methods the orchestrator can use. The skill list deliberately differs from the command list: advisor and teach, for example, are methods rather than matching entries in the ten-command reference.

  • advisorskillAdvisor-driven development: the orchestrator plans, cheaper models execute, and complexity escalates back up.
  • brainstormskillExplore intent, requirements, and design before any building begins.
  • dreamskillConsolidate memory: orient, gather, distil, and prune.
  • handoffskillProduce a structured handoff so context survives the end of a session.
  • morningskillAssemble the morning briefing from maintenance state and active work.
  • nightskillRun the end-of-day strategy review and consolidation.
  • prefetchskillLoad the context a task will need before the task starts.
  • recallskillRetrieve relevant memory across the brain for a query.
  • rememberskillCommit text to the shared memory layer.
  • teachskillCapture your methodology, patterns, and operating principles into memory drafts as you work.

A specialist's brief should still name its outcome, boundary and evidence. Having a skill available doesn't authorise work outside the user's instructions.

Call the memory tools through the right server

The MCP server is named ari-os-cortex. The installer can register it; the original manual Claude command is:

claude mcp add ari-os-cortex -- python -m ari_os.tools.cortex.mcp_server stdio

These are the ten documented tool signatures:

  • brain.recall(query, mode='default', k=12, token_budget=4000, session_id)toolRecall the most relevant past context for a query.
  • brain.remember(text, layer='semantic', source)toolStore text. Without an explicit source, the wrapper derives its source ID from the text hash.
  • brain.lineage(chunk_id)toolTrace where a memory came from.
  • brain.regions()toolList the memory regions.
  • brain.tracts(n=100)toolList the strongest connections.
  • brain.entities(kind, k=50)toolList known entities.
  • brain.relations(entity, k=50)toolList an entity's relations.
  • brain.modes()toolList the retrieval modes.
  • brain.see(image_path, mode='visual')toolCaption an image. Requires LENS, an enabled LLM setting and a working vision backend.
  • brain.lens(slug)toolRead a local or indexed aesthetic card. Requires LENS; no model call.

When source is omitted, the brain.remember wrapper trims the text and derives its source ID from the first 16 hexadecimal characters of its SHA-256 hash. Supplying a source changes that path; don't treat this wrapper as a promise of unconditional deduplication. The other tools expose retrieval, lineage, regions, connections, entities, relationships and modes so an answer can lead back to its source.

LENS starts off. Once enabled, brain.lens retrieves a local card or indexed content without a model call. brain.see additionally requires an enabled Cortex LLM setting and a working vision backend. Inspect unavailable or missing-card responses instead of treating a registered tool name as proof of a working capability. The MCP source defines those separate paths.

Dispatch a bounded worker

Write the brief, choose the working directory and make the result reviewable before starting the worker.

one prompt, fanned out

An animated example: five parallel workers, then two dependent workers. No jobs or checks run here.

This illustration shows a possible orchestration pattern. The dispatch start command below launches one worker; it doesn't itself create the illustrated five-plus-two workflow or its preview gate.

The dispatch lifecycle
A brief goes to a detached worker. Inspect its result and any unresolved questions before accepting the work.
python3 -m ari_os.tools.dispatch start --executor sonnet --task-file BRIEF.md --cwd ./worktree --label mytask

The documented executors are haiku, sonnet and opus. Choose one capable of the task and escalate when the work requires it. --add-dir adds a directory to the worker's access scope.

Two old claims need a narrower reading. Dispatch rejects a --cwd that Git identifies as a repository root, including a linked worktree's root. The example's ./worktree must therefore name a permitted working directory, not merely any directory called a worktree. Choosing a subdirectory is not a filesystem sandbox. Its --read-only flag disables the named Write, Edit, MultiEdit and NotebookEdit tools. It does not prove that shell commands or other tools cannot write.

The checked dispatcher also skips permission prompts by default. Setting ARI_OS_WORKER_SKIP_PERMISSIONS=0 omits that launch flag. These are concrete implementation limits to understand before giving a detached process access to your work. See the pinned dispatcher.

Inspect workers and their questions

python3 -m ari_os.tools.dispatch list
python3 -m ari_os.tools.dispatch questions
python3 -m ari_os.tools.dispatch answer <worker_id> --answer "..."

list reports tracked workers. questions reads their outstanding question files.

The checked answer implementation has a limitation: it composes an answer task, removes the question file and prints the first 200 characters. It does not send that answer to a live worker or restart one. Don't mistake clearing the question file for resuming the job. Confirm the continuation path in the version you are actually running.

Use the monitor as a view of the work

python3 -m ari_os.tools.monitor

The monitor opens at http://localhost:7777. It provides a shared view of progress, questions and completion reports. A displayed completion still needs the evidence required by the brief.

Inspect and change the control settings

python3 -m ari_os.tools.arios

The documented control-panel commands are:

  • keys reports whether the expected provider environment variables are present; it does not configure or validate the keys.
  • theme <name> for the monitor's appearance.
  • toggle <feature> on|off for a feature setting.
  • update invokes the installer with --update, reapplying managed files from the local checkout. It does not fetch a new release.
  • cortex <setting> [value] for memory configuration: status, embeddings <auto|google|ollama|off>, mode <name>, wander on|off, ears on|off or lens on|off.

Inspect the memory settings:

python3 -m ari_os.tools.arios cortex status

Or record focus as the global control-panel preference:

python3 -m ari_os.tools.arios cortex mode focus

That preference is separate from the Cortex CLI's per-workspace mode store and an explicit recall/retrieve mode. The inspected direct calls default to default; do not assume changing the preference changes every call. The brain guide explains those paths and the embedding-setting integration gap. The advanced guide separates the optional surfaces and their actual gates.

You direct from the chair. The workers run in the shadows.

Keep the division visible: a worker can execute the task, the monitor can report its state, and you still decide whether the evidence supports accepting the result.

[ comments ]

guests welcome. members show first in the list

no comments yet. start the thread_

1 / 10