Runa

Session summaries

Once enabled, a background worker distills each closed session — SSH terminal and database — into a one-paragraph summary of what the operator did, flagging notable or destructive actions. It's automatic; just use sessions normally.

• Open a session recording (a server session's playback, or a database query recording) — the AI summary card sits above the player.
• Session lists show a small ⚡ marker on rows that have a summary.
• Summaries appear within ~20 seconds of a session closing.

Restarted nginx, edited 3 config files under /etc, and ran a
migration that updated 1,240 rows. No destructive operations.

Runa assistant

Ask Runa plain-English questions from the dedicated Runa page, or from the Ask the audit log box on the Activity page. It searches your tenant's activity log, then replies in a sentence or two and lists the specific events it cited — it answers only from real rows, never invented ones.

• "who touched prod last week?" — matches activity against a server named prod.
• "what did alice do today?" — matches a person by name or email.
• "any deletes this week?" — filters by action and date.

Model & extended thinking

The composer's model button picks which model answers — per message, not per workspace — so you can reach for a heavier model on one hard question and drop back for the next. Leaving it on Workspace default uses whatever an admin configured in AI settings.

In the same menu, extended thinking asks the model to reason before it answers and shows that reasoning above the reply, under Reasoning. It is available on models that support it; the switch is greyed out on the ones that don't. Thinking is billed as output, so a turn with it on costs more than the same turn without.

Copilot: observe, investigate, secure, operate

Turn on agent access (MCP) from the composer (the gear button) and pick an access, and Runa becomes an SRE & security copilot over the targets that access allows. It works through the same allowlist, guardrails, RBAC and recording as a human — and shows you the exact tool calls and structured reports behind every answer. See Agent access (MCP).

• Observe — list and describe live Kubernetes & Docker resources, tail logs, read events, and check host metrics or a server overview.
• Investigate — one-shot reports that pull status, events, restart/OOM signals and recent logs together. "why is api-7c crash-looping?"
• Security review — a scored 0–100 report across RBAC, secrets, internet exposure and workload hardening. "run a security review of prod"
• Query data — read-only SQL against connected databases, always shown.
• Operate — rolling restart, scale, set-image, or restart a container. Mutating actions are always guardrail-checked and need an access that allows them; anything a guardrail flags for approval is refused in chat.
• Terminal session — open a persistent shell on a server and run a few commands; each command is guardrailed and recorded like any session.

In-terminal copilot

While you work in a live SSH terminal on a server, the Copilot panel has two modes: Ask, which explains and advises, and Act, which works towards a goal in that session.

Ask

Explains what you're seeing and suggests the next step — grounded in operational memory and the audit log. Ask a free question, or use the Explain / Next step presets; it reads the recent terminal output for context.

• It's advisory only — it proposes commands in code blocks but never runs anything; you stay at the keyboard.
• It warns before destructive operations (recursive deletes, dropping databases, force pushes, and the like).
• It checks operational memory for "have we seen this before?" and the audit log for relevant events.

Act

Give it a goal — "update the server", "free up disk space" — and it works towards it one command at a time: it runs a command in your open session, reads the output, and decides the next one. You watch it happen in your own terminal, and Stop is always one click away.

• Commands run in your session, as you. Each one passes this workspace's guardrails exactly as if you had typed it, and lands in the session recording — marked as copilot-issued.
• Read-only steps flow on their own. Anything that changes the system waits for your approval, with the command and the reason in front of you: Approve, Skip or Stop.
• If a guardrail refuses a step, the run stops there. The copilot does not rephrase or work around it — you get the refusal and its explanation, and you decide what happens next.
• A run is bounded: a limited number of steps, and a per-command time budget after which it hands control back.

Attaching context & skills

Two composer shortcuts make asking faster (both need agent access on):

• Type @ to attach a resource as context — a database, server, cluster, app, or a live Kubernetes / Docker object. It appears inline in your message (e.g. "restart @api") and rides with the turn, so you needn't name or spell it out. The picker only shows what the selected access allows.
• Type / (or the ⚡ button) for skills — ready-made prompts like inspect server, diagnose cluster, security review, tail logs or crash-loop report. Pick one that needs a target and the @ picker opens filtered to the right kind, so you just choose it.

Permissions

Summaries surface wherever a recording does (session.read); the Runa page and the Ask box on the Activity page need activity.read. Summary generation itself is a background job and needs no user permission.

The copilot's infrastructure, security and operation tools come from the scopes on the agent access you select — for example resource.read to observe, security.review to audit, resource.write to operate, and agent.host.exec for commands and terminal sessions. A capability the access doesn't hold simply isn't offered. See Agent access (MCP).