CLI Masterclass

The Opta CLI is your primary interface to the Opta Local stack. It provides interactive AI chat, autonomous task execution, model management, session control, and daemon lifecycle commands. It seamlessly connects to the local daemon, which orchestrates sessions and proxies requests to Opta LMX for inference.

Under the hood, the CLI doesn't perform inference itself. Instead, it connects to the Opta Daemon (running in the background), which manages long-lived sessions, tool permissions, and communication with the LMX server. You can control the daemon directly using commands like opta daemon start or view its health via opta status.

The CLI operates in two fundamental modes designed for different workflows. Chat Mode is an interactive conversation session. You type messages, the model streams back responses token-by-token in real time, and you manually approve tool executions. Do Mode runs an autonomous agent loop. It takes a natural-language task, creates a plan, and automatically executes safe tools until the task is complete.

Both chat and do modes have access to the same powerful toolset. Read-only tools like read_file and search_files are auto-approved by default. Destructive tools like write_file or run_command trigger a Permission Prompt where you can approve, deny, or auto-approve for the remainder of the session.

Tool: write_file
Path: src/auth/validate.ts
Content: (47 lines)

[A]pprove  [D]eny  [A]ll for this tool  [Q]uit

Understanding what the AI "sees" is critical. Use opta context map to generate a live Context Constellation. This visualizes exactly which files, terminal buffers, and API documentation are currently loaded into the AI's active memory, along with their associated token weight. It helps you trim unnecessary context to improve latency.

Autonomous execution involves risk. Opta CLI mitigates this using Time-Travel Introspection (opta rewind). Before triggering a chain of tools in Do Mode, the Daemon captures an ephemeral snapshot of your workspace. If the agent hallucinates or goes down a destructive path, you can instantly roll back not just the files, but the AI's internal short-term memory to the exact moment before divergence.

For massive refactoring tasks, a single thread is a bottleneck. By appending --swarm to your command, the CLI orchestrates multiple local models via LMX. A Director Agent breaks down the prompt into sub-tasks, spins up 2-3 worker agents (e.g., DeepSeek for business logic, Llama 3 for unit tests), and merges their outputs asynchronously—all executing privately on your metal.

opta do --swarm "Refactor the authentication flow to use JWTs instead of session cookies, and write unit tests for the new middleware."

Keeping track of resource constraints is vital when running local LLMs. Run opta top to open the Holographic TUI. It provides a real-time, high-density stream of active session memory banks, context shifting overhead, and VRAM pressure—rendering the normally invisible daemon operations into a beautiful, matrix-like control center.

Agentic tasks frequently require interacting with the outside world. By running opta do --browser, the CLI spins up an automated Chromium instance equipped with a custom Opta Chrome Overlay. The agent natively navigates websites, extracts DOM data, and interacts with complex UIs just like a human, while providing a clear visual indicator of its active operations.

To ensure maximum code quality, invoke Opta's partner persona via /atpo. Atpo is an abrasive, hyper-critical analyzer that evaluates your repository across 5 rigorous dimensions (Performance, Quality, Consistency, Architecture, Security) and generates a structured GenUI HTML report before handing execution targets back to Opta.

Opta CLI integrates directly with accounts.optalocal.com. Run opta login to securely pull your Cloud identity, LMX API keys, tool configurations, and autonomy presets into your local machine. This guarantees a unified session experience across all Opta Local apps via Supabase SSO.

When solving massively complex tasks, the standard agent loop may get lost in the weeds. Run opta do --ceo to shift the AI's role from "worker" to "executive director". In CEO Mode, Opta does not write code. It drafts architectural strategies, spawns specialized child agents (e.g., Designer, Database, DevOps), reviews their PRs, and dictates the overall merge timeline.

Opta is designed for endurance. While most agents crash or loop infinitely when left unattended, the Opta CLI utilizes advanced error-recovery state machines, self-correction protocol limits, and exponential backoff loops. You can assign a 60-minute background refactor, step away, and trust the daemon to navigate npm ERR! traps safely without nuking your directory.

Evaluate local hardware capabilities via the integrated benchmarking suite (opta bench). Built on a local Fastify and React runtime, it performs adversarial stress-tests comparing Llama3 against DeepSeek across metrics like TOK/S, latency-to-first-token (TTFT), and structural logic consistency under heavy payload tasks like AI News synthesis.

The CLI automatically serializes the semantic intent of your completed sessions into local vector storage. During future, unrelated tasks, if the Daemon detects similar stack traces or error archetypes, it uses Retrieval-Augmented Generation (RAG) to quietly inject your past successful debugging steps into the agent's prompt, saving countless tokens.

You do not need a secondary application to orchestrate your local weights. You can securely pull HuggingFace models (e.g., GGUF format) and configure system prompts directly through the CLI lifecycle commands like opta models pull <repo/name>. The daemon streams the multi-gigabyte files efficiently to your centralized cache path.

The Opta CLI is not just a chat interface; it is a hyper-capable, local orchestration engine. It unifies all these disparate features—interactive steerage (Chat mode), autonomous agency (Do mode), Time-Travel rewind, multi-agent swarms, the ATPO critical analyzer, visual DOM interactions, and executive CEO mode—into a single terminal experience. The ultimate purpose of the CLI is to transform your local machine into a private, zero-latency software factory where models execute massive refactors natively alongside you without compromising security or context awareness.