Documentation

Everything Eyano Code can do, and how to drive it.

Overview

Eyano Code is a terminal coding agent. You describe a task; it reads and edits files and runs commands to accomplish it. It runs the agent loop locally on your machine and routes model calls through the Eyano backend, billed to your existing Eyano subscription — the same credit pool as Eyano Chat.

It works in two modes:

  • Prompt mode (default) — you type a message, the agent works until it has an answer, then stops and waits for you. One task per message, with you reviewing between turns.
  • Loop mode (/loop) — you give a goal once and the agent runs autonomously, iterating until the goal is met (or a limit is hit). Hands-off — see the Loop mode section below.

New here? Install it from the CLI page, run eyano login, then eyano in any project folder.

Commands

Run these from your shell:

Command What it does
eyano / eyano chat Interactive agent (the TUI) — chat and act. Auto-resumes this folder's last conversation.
eyano "<task>" / eyano do "<task>" Run a single coding task non-interactively.
eyano ask "<question>" One-shot question, no tools.
eyano models List the models available to the CLI.
eyano model <code> Show or set the default model.
eyano login / eyano logout / eyano whoami Manage your session.
eyano mcp List configured MCP servers + connection status.
eyano mcp login <server> / eyano mcp logout <server> Authorize / clear a remote (OAuth) MCP server.
eyano update / eyano version Update on demand / show the installed version.

Flags

  • --model <code> (-m) — pick the model for this run.
  • --yes (-y) — auto-approve file writes and shell commands.
  • --resume (-r) — list this folder's conversations and pick one.
  • --new — force a fresh conversation (ignore auto-resume).
  • --verbose — show full tool diffs and output (summarized by default).
  • --remote — drive this interactive session from your phone (see Remote control).

The interactive TUI

Running eyano with no task opens the full terminal UI:

  • Chat and act in one place — ask questions or give tasks; the agent reads, edits, and runs commands as needed.
  • Multi-line input — Enter sends; Shift+Enter (or Option+Enter, or \ then Enter) starts a new line.
  • Markdown rendering — answers render with headings, bold, lists, and colored code.
  • Type-ahead queue — send a message while the agent is working and it runs next (the footer shows the count). Press ↑ on an empty line to pull the last queued message back and edit it; Esc clears the queue.
  • Collapsible tool output — long file reads and command output are summarized; Ctrl+O expands or collapses the full output.
  • Inline diffs — every edit shows a colored diff before it's applied.
  • Approve-mode toggle — Shift+Tab cycles between approving each action and auto-approving (Claude-Code style).
  • Scroll — PgUp/PgDn by a page, ↑/↓ or the mouse wheel by a line.
  • Esc — close a panel, cancel a pending approval, interrupt a run, or clear the input line.
  • Ctrl-C — stop the current task (or loop); press again to quit.

Slash commands

Inside the TUI:

Command What it does
/loop <goal> Run autonomously toward a goal (see the Loop mode section below).
/remote [on|off] Toggle phone remote control (see Remote control).
/usage (/credits) Credits used / remaining, reset date, and this session's spend.
/status Version, environment, login, plan, current model, conversation.
/config (/settings) Settings, default model, and your always-allowed tools.
/stats Activity heatmap and usage totals.
/mcp List configured MCP servers + connection status (see MCP servers).
/model [n|code] (/models) List models, or switch by number or code.
/new Start a fresh conversation.
/resume [n] List recent conversations, or resume one.
/clear · /help · /quit Clear the screen · show help · exit.

In the panels (/usage, /status, /config, /stats), use ←/→ or Tab to switch tabs, r to cycle the date range (on Usage/Stats), and Esc to close.

Loop mode

/loop turns Eyano Code loose on a goal: it keeps iterating — taking concrete actions each round — until it's done, then returns you to normal prompt mode.

/loop <goal>                        run until the goal is complete
/loop <goal> :: <success command>   also stop when the command exits 0
/loop --max=20 --budget=150 <goal>  cap iterations / credits

It stops on any of these:

  • the agent decides the goal is fully achieved,
  • your :: success command exits 0 (e.g. :: npm test),
  • the iteration cap (--max, default 12) is reached,
  • the credit budget (--budget) is reached,
  • you press Ctrl-C.

While looping, file writes and commands are auto-approved so the agent doesn't stall — the iteration and credit caps are your guardrails. Example: /loop make the build pass :: npm run build edits, builds, fixes failures, and repeats until the build is green.

Images & attachments

Attach images or PDFs by putting the file path in your message — there's no separate command. A path is picked up when it points to a real file with a supported extension (.png, .jpg, .jpeg, .gif, .webp, .pdf; up to 5 MB). Quotes, a leading @, and file:// URIs all work.

Attachments are sent only when the current model can see images — otherwise they're skipped with a note to switch to a vision model (e.g. Claude). On a vision model the agent's read_file tool can open an image or PDF directly too.

Remote control

Drive an interactive session from your phone: start with eyano --remote, or toggle it live with /remote on (and /remote off). There are no pairing codes — it links through your own account, so opening Eyano on your phone (signed in to the same account) attaches it to the running terminal session.

Once attached, the phone sees the live transcript, can send messages and slash commands, and can answer approval prompts — whichever side responds first wins. The TUI footer shows 📱 with the number of attached devices.

MCP servers

Eyano Code can load Model Context Protocol servers to add extra tools. Configure them in mcp.json — globally at ~/.config/eyano/mcp.json, or per project at ./.eyano/mcp.json (project entries override global):

{
  "mcpServers": {
    "my-tool": { "command": "npx", "args": ["-y", "<server-pkg>"] },
    "remote-tool": { "url": "https://example.com/mcp", "type": "http" }
  }
}

Local stdio servers use command + args (plus optional env); remote servers use url + type (http or sse, plus optional headers). Add "disabled": true to skip one. Configured servers connect at startup; their tools appear to the agent as <server>__<tool> and need approval like any other mutating tool. Manage them with eyano mcp (list + status), eyano mcp login <server> (OAuth for remote servers), and /mcp in the TUI.

Models

Only models flagged for the CLI are available (eyano models). By default Eyano Code uses the cheapest code-enabled model; switch any time with /model or set a default with eyano model <code>.

Selection precedence: --model flag → saved default (eyano model <code>) → EYANO_MODEL env var → the cheapest available model.

Tools

The agent works through a fixed tool set, executed on your machine:

  • read_file, list_dir, grep, glob — read and search (never need approval).
  • edit_file — targeted exact-substring replacement (preferred for edits).
  • write_file — create or overwrite a whole file.
  • run_bash — run a shell command (git, build, tests, anything else).
  • spawn_agents — the agent can launch up to 6 read-only sub-agents in parallel (on a cheap, fast model) to explore the codebase at once; they only read and search, then report back. It decides when to use this — it isn't a command.
  • MCP tools — any tools from your configured MCP servers, named <server>__<tool> (see MCP servers).

Approvals & permissions

Read-only tools run freely. Mutating tools (edit_file, write_file, run_bash) show a diff or the command and ask what to do, with a rich menu:

  • Yes, once — allow this single action.
  • Always allow <tool> — stop asking for this tool, saved per-project to ./.eyano/permissions.json (it survives restarts).
  • Allow everything — auto-approve the rest of this session (in memory only).
  • No — skip the action.
  • No, and tell Eyano what to do instead — deny and hand back a steering instruction.

Pass --yes to start a run with everything pre-approved (use only in trusted or sandboxed directories). In non-interactive runs without --yes, mutating actions are denied (read-only). Loop mode auto-approves by design.

Conversations & resume

Each conversation is tied to the folder you launched in. Running eyano again in the same folder continues the most recent conversation; --resume (or /resume) lets you pick a previous one; --new (or /new) starts fresh. The folder's index lives in ./.eyano/conversations.json and is scoped per environment, so dev and prod conversations don't collide.

Memory

Two layers:

  • Cloud (base): the conversation history itself — replayed each turn, so the agent remembers the thread.
  • Local (reference): files the agent saves under ./.eyano/<conversation-id>/ (architecture notes, decisions, progress). These aren't loaded every turn — the agent notes what it saved and reads them on demand, so context stays lean while durable knowledge persists across sessions.

Everything Eyano Code writes lives under ./.eyano/. In a git repository the agent adds .eyano/ to your .gitignore automatically, so this private scratch space is never committed.

Environments

Eyano Code talks to production (eyano.chat) by default. Set EYANO_ENV to switch:

EYANO_ENV Backend
prod (default) eyano.chat
dev alpha.eyano.chat
int beta.eyano.chat
local your local backend (127.0.0.1)

Conversations are tracked separately per environment.

Staying up to date

Eyano Code checks for updates once a day and applies them in the background. Run eyano update to update immediately, or eyano version to see what's installed. Set EYANO_NO_AUTO_UPDATE=1 to disable the background check.

Troubleshooting

  • not logged in — run eyano login.
  • no code-enabled models — no model is flagged for the CLI on your account; contact an admin.
  • Out of credits — top up at eyano.chat/plans. Credits are shared with Eyano Chat.
  • Connection drops — the agent reconnects and retries once; press Ctrl-C to stop the current task (again to quit).