korTTY — AI-Driven Terminal Experience

01 — AI Agent & Planning

The agent doesn't advise. It logs in and does the work.

Other tools paste commands into your clipboard and wish you luck. korTTY's agent runs inside the active SSH session: it reads the real environment, plans safe non-interactive commands, executes them — with an approval gate for anything destructive — and writes the answer back into your terminal.

agent <task>agent-ask <question>agent-plan <task>TAB — command & history completion

01

Shell-native start

Type agent at any prompt — local or remote. korTTY intercepts the shortcut before the shell sees it and hands the agent your goal plus a compact session snapshot, including the working directory you're actually in.

02

Plan first, if you prefer

agent-plan starts interactive planning: the model asks clarifying questions, offers approaches, and writes a final plan. Implementation starts only after you accept it. Micromanagers welcome.

03

Transparent runs

Every run logs its AI profile and model, expandable 💭 rows show the model's full reasoning where the provider exposes it, and runs can be paused at safe checkpoints, resumed, rerun, or cancelled. Export to Markdown, YAML, JSON, PDF and more.

04

Scales to your splits

Parallel runs in different split panes, up to five concurrent runs per terminal, a dockable activity panel, and a per-terminal status badge — ✋ awaiting input · ⚡ working · ⏸ paused · ✓ finished — in tab titles and the dashboard.

02 — AI Swarm

One question. Your whole fleet answers.

Broadcast one agent task to many servers at once (Ctrl/Cmd+Alt+S) — even servers without an open terminal, via background SSH. Per-server agents run in parallel and their answers land in a single comparison table, one row per host, deviations flagged.

12 running3 slow9 done

The real status strip, recreated: one orb per agent, adaptive slow-run detection, click an orb to jump to its row. Pause, resume, restart or stop one agent — or the whole swarm.

03 — Coding Agents

Claude Code is waiting for an answer. korTTY tells you.

korTTY recognises Claude Code, Codex and Gemini CLI in your local shell tabs and tracks what each one is doing: working, blocked on a question, done, or idle at its prompt. Every split pane is tracked on its own, and the screen is read inside korTTY, on your machine.

Claude CodeCodexGemini CLIView → Coding Agents

Coding Agents3 agents · 2 windowsNext blocked

Claude CodeWaiting for you · 2:14 Window 1 › api › Pane 2 · ~/proj/api Do you want to proceed? › 1. Yes FocusynEnterEsc↑↓Ctrl+CExplainRename…

CodexWorking · 0:38 Window 1 › infra · ~/proj/infra ✳ Editing terraform/main.tf… (esc to interrupt)

Gemini CLIDone · 1:02 Window 2 › web · ~/proj/web ✓ 3 files changed, tests pass

Prompt the selected agent — Enter sends, Shift+Enter breaks the line Claude Code needs a decision — answer with y, n, Enter or Esc

The Coding Agents panel, recreated: agents waiting for you sort to the top, every row carries the screen line that produced its state, and the quick keys answer the dialog without switching tabs.

web01 · xterm-256color · UTF-8 · 198 × 52 ✋ 1·⚡ 1·✓ 1

The status strip at the right end of the status bar: waiting, working and done counts — one click from the agent that needs you.

Five states, ordered by urgency

State	What it means
BLOCKED	Waiting for you — a permission dialog, a question picker or a (y/n) prompt is on screen.
DONE	Finished. Stays marked ✓ until you look at the pane.
WORKING	Thinking, running a tool or streaming output.
IDLE	Running, prompt empty, waiting for your next instruction.
UNKNOWN	The process is there, but no rule matches and the rule file asks for a strict result.

01

Two observations, or nothing

Detection needs both: the pane's process tree must contain a known agent — directly, through npx, or as a node, bun or deno script — and the visible screen must match that agent's rule file. A stray claude in a shell script raises no alarm. The rules are small JSON files you can override per agent.

02

Marked where you already look

Every dashboard row hosting an agent shows a chip after the protocol badge (✋ claude 2:14) and an accent bar on its left edge — amber waiting, blue working, green done. Group rows carry a rollup such as ✋ 1 · ⚡ 2, so a waiting agent stays visible inside a collapsed group, and split tabs grow one row per pane.

03

A strip in the status bar

While at least one agent is known, the right end of the status bar counts them: up to three chips, the waiting dot pulsing while the window is in front. A click jumps to the next agent waiting for you, and the tab title carries the same glyph.

04

The screen stays on this machine

Screen text is analysed only inside korTTY, in memory. Nothing is sent to a service, written to disk or handed to the AI assistant — detection is pattern matching against local rule files, and it switches off under Settings → Terminal → Coding agents.

05

Or let a script do the herding

Everything the panel does is reachable from korTTY's control API and its kortty-cli client: list agents, read their state, prompt them, answer their questions, start a new one in a split pane, or subscribe to their state changes as a JSON event stream. The socket is local and off by default.

One exception: in the Flatpak package the local shell runs on the host through flatpak-spawn, so the agent's process tree is out of reach and no agent is detected there. The DEB, RPM, pacman and tar.gz builds see it. SSH and Mosh tabs are never analysed either — the agent runs on the other machine.

04 — LLMs, in-process

No Ollama. No LM Studio. No excuses.

korTTY is the only terminal that runs GGUF models itself: an integrated llama.cpp runtime starts one authenticated, loopback-only llama-server per model — offline, on 127.0.0.1, with a generated API key. Several models run concurrently; idle tensors unload after a configurable timeout.

The Hugging Face manager searches GGUF repos with quantization, license, context and hardware estimates, downloads immutable revisions with pause/resume, and verifies every byte with SHA-256. A beginner assistant sets up Text, Coding and embedding slots and runs a real local chat test before it saves anything.

Model download

bartowski/Qwen_Qwen3-4B-GGUF · Q4_K_M · Qwen3-4B-Q4_K_M.gguf (1/1)

0.0 GiB of 2.5 GiBSpeed 18.0 MiB/s · Remaining 02:22

Downloading — SHA-256 verified on completion

Recreated from the Local Models manager. Runtimes are Ed25519-signed and source-pinned; macOS prefers Metal, elsewhere CPU with Vulkan fallback.

korTTY Local Models manager: installed GGUF models and Hugging Face search

05 — Local RAG

Your runbooks, indexed. Never uploaded.

Knowledge stores index files and folders into a local HNSW vector store after an allowlist preview. Retrieval sends only bounded excerpts — at most six, two per source, capped at 4,000 tokens — wrapped as explicitly untrusted context and cited as [R1] in answers. The complete store never leaves the machine; autonomous agent runs need explicit RAG opt-in.

korTTY Knowledge Stores: local RAG sources, sync state and retrieval test

06 — Skills & Profiles

Teach it your house rules

AI Skills are reusable local instruction blocks — "we deploy with systemd, never Docker" — attached to Chat, Agent, or both, imported and exported as Markdown, and optionally filtered so only skills matching the current request are sent.

AI Profiles route work to the right brain: per-profile endpoint, model and key — OpenAI-compatible, native Anthropic, LM Studio auto-mode or the integrated local runtime — with role routing for Text vs. Coding, reasoning effort, token budgets and quotas. A setup wizard does the boring part.

korTTY AI Skills settings: reusable instruction blocks with per-skill targets

07 — AI Manager

Chats that render like a lab notebook

AI answers render Mermaid diagrams, LaTeX math, sanitized SVG and inline images locally — no remote renderer. Follow up, switch profile per chat, save generated scripts straight into the Snippet Manager, and export conversations to PDF or Markdown. The modeless manager (Ctrl/Cmd+Shift+Y) keeps every saved chat one focus away.

korTTY AI Manager: profiles, local models, knowledge stores and saved chats

08 — The terminal itself

A proper terminal first. The brain is a bonus.

Tabs, multi-window with drag-to-move sessions, Mosh for flaky links, and local shells — PowerShell, cmd.exe, WSL, Git Bash or your $SHELL — in the same tabs, with the same AI, logging and recording.

01

Tabs, windows, projects

Multiple SSH connections per window, multiple windows per brain, drag tabs between them — splits included. Save connection sets as projects and restore them with history.

02

Local shell, zero network

A Local Shell protocol spawns your machine's shell in a real PTY — no host, no port, no authentication. Custom command field for pwsh.exe, wsl.exe -d Ubuntu or anything else on disk.

03

Comfort where it counts

Zoom with Ctrl + wheel or Alt+±, reset with Alt+0. F12 gives terminal-only fullscreen. OSC 8 hyperlinks are clickable — ls --hyperlink finally pays off. Optional background transparency, new in 2.7.

04

Logging & replay recording

Automatic session logging, plus lightweight per-tab replay recordings with timeline seeking and 1–20× playback — exportable to WebM/VP9 or MKV/FFV1 when ffmpeg is around.

09 — Terminal emulations

One terminal that speaks 21 dialects

Under the hood, the SithTermFX engine emulates 21 terminals — from today's xterm-256color across five decades of DEC, IBM, Wyse, TeleVideo and HP hardware down to PETSCII. Set it per connection or in QuickConnect: korTTY requests the matching PTY type over SSH and exports TERM, so the host sends exactly the sequences the emulator renders. In the app the picker is searchable; try it here:

Choose a terminal emulation

TERM: xterm-256colorStream mode256 colors / TrueColor80×24

The default and the right choice for anything current: the full xterm control set, 256 colors and TrueColor, mouse reporting, modern keys. Every Linux, BSD and macOS host understands it — if you don't know what to pick, pick this.

TERM: vt100Stream modeMonochrome80×24

DEC's 1978 classic — the terminal that made ANSI escape sequences a de-facto standard. Minimal and monochrome, it is the lowest common denominator: serial consoles, switches, UPSes and embedded appliances all fall back to it.

TERM: vt102Stream modeMonochrome80×24

The 1981 refinement of the VT100 with insert/delete editing built in. Many old full-screen Unix programs were written against exactly this feature set.

TERM: vt220Stream modeMonochrome80×24

The 1983 generation: extended keyboard (F-keys, Find/Insert/Remove) and international character sets. A safe pick for older Unix hosts, industrial controllers and lab instruments.

TERM: vt320Stream modeMonochrome80×24

The refined VT220 successor of 1987, ubiquitous on DEC VMS sites. Choose it when a VMS or legacy DEC host announces it.

TERM: vt420Stream modeMonochrome80×24

1990: dual sessions on one screen and rectangular editing operations. Late OpenVMS installations and terminal servers expect it.

TERM: vt520Stream modeMonochrome80×24

DEC's last terminal generation (1993), multi-session capable — for the OpenVMS shops that never stopped.

TERM: IBM-3279-2-EBlock mode (page-oriented)16 colors80×24

Not a VT at all: the block-mode data stream of IBM mainframes. The screen is filled locally and transmitted as a whole page — for z/OS, TSO, CICS and IMS sessions.

TERM: IBM-3179-2Block mode (page-oriented)16 colors80×24

IBM's block-mode protocol for midrange systems: AS/400, iSeries and today's IBM i. Field-based forms, function keys, page-at-a-time transmission.

TERM: dttermStream mode16 colors80×24

The terminal of the CDE desktop, at home on classic Solaris, AIX and HP-UX workstations. Pick it when profile scripts on old commercial Unix expect TERM=dtterm.

TERM: wy50Stream modeMonochrome80×24

The 1983 budget terminal that sold in the millions. Point-of-sale, warehousing and character-based ERP systems ran on it — and their successors still emulate it.

TERM: wy60Stream modeMonochrome80×24

The best-selling Wyse of all time and standard equipment for SCO Unix and multiuser business systems; countless vertical applications are keyed to its escape codes.

TERM: wy160Stream mode16 colors80×24

The color-capable Wyse, for character applications that got a coat of paint without being rewritten.

TERM: tvi910Stream modeMonochrome80×24

TeleVideo's CP/M-era workhorse (1981). Industrial controllers and BBS packages still reference its simple escape set.

TERM: tvi920Stream modeMonochrome80×24

The 910's bigger sibling with a full keyboard — a fixture of early multiuser systems.

TERM: tvi925Stream modeMonochrome80×24

TeleVideo's best seller, its escape set copied by a generation of clones. Still met in legacy manufacturing gear.

TERM: hp2392Stream modeMonochrome80×24

HP's terminal for HP 3000 (MPE) and HP 9000 (HP-UX) systems. Classic HP applications address its softkey function keys directly.

TERM: hp700-92Stream mode16 colors80×24

The later HP generation for MPE/iX shops — same softkey model, now with 16 colors.

TERM: scoansiStream mode16 colors80×25

The PC console dialect of SCO Unix and OpenServer: 80×25, 16 colors, PC line graphics. Legacy branch-office servers and POS backends still speak it.

TERM: ctermStream modeMonochrome80×24

DEC's CTERM — the remote-terminal dialect of the DECnet world, for VMS hosts reached through DECnet-style gateways.

TERM: petsciiStream mode16 colors40×25

Commodore's character set with its block-graphics symbols, 40×25 — for retro BBSs reachable over telnet/SSH bridges. Yes, somebody needed it. korTTY has it.

10 — Session journal

The session writes its own report

Every terminal tab can keep a journal: server output and typed commands go into an append-only capture log, an AI condenses the activity into a readable timeline, and screenshots and notes drop in from the journal bar. Enable it per connection, or mid-session with Ctrl/Cmd+Alt+T — the existing scrollback is imported first, so the timeline covers what already happened.

korTTY session journal viewer: header with connection details and counts, one AI-summarised timeline entry marked Important, command and output excerpts

What this window shows: a 27-minute maintenance session on web01, condensed by the AI into one timeline entry it flagged Important — three commands against the nginx service (green) and the output excerpt that made it interesting (blue): a missing-file error in the error log. Clicking an entry slides in the exact capture-log range behind it, with its own search.

01

Passwords stay out of it

Typed input is captured as complete submitted lines only. When the server output ends in a password prompt — password:, [sudo] password for …, passphrase, PIN and localized variants — the next line is suppressed and logged as a placeholder, never buffered. The connection's own password is replaced by *** wherever it would appear, and capturing typed input can be switched off per connection entirely.

02

Follow it live — and fix it live

View → Live Journal (Ctrl/Cmd+Alt+L) docks the full journal page beside the terminal, updated in real time: new AI summaries, notes and screenshots appear moments after they happen, and the Live Log streams the capture log in follow mode — scroll up to pause, back down to resume. Because it is the real page, adjusting works right there: right-click an entry to set its marker, right-click a screenshot to annotate it, add notes and screenshots from the header. A finished AI-agent run files its own card with your prompt, the answer and the token count.

03

An AI that keeps minutes

Every five minutes — configurable globally and per connection — the summarizer reads the newest capture-log lines and appends a short entry: title, summary and a suggested marker (info, important, error). The end of the session adds a closing summary of what was accomplished and what failed, and optionally lets the AI name the journal. Without AI the timeline still records raw activity.

04

One folder, nothing to install

Each journal is a self-contained directory under ~/.kortty/journals: the curated journal.xml, the capture log as JSON Lines (XML or YAML on request), rotated parts compressed to .zst — history is compressed, never deleted, and older journals' .gz parts open exactly as before — your screenshots, and journal.html. That page has no external resources: it opens in the viewer or any browser, scales 70–250 %, follows your light/dark preference, and searches the whole timeline.

05

Logs that stay small

The capture log is built to shrink. Finished parts are compressed with zstd automatically, and consecutive identical output lines — progress loops, tail -f repeats — are coalesced syslog-style into one entry with a repeat count: the viewer shows the run as line ×12, while copying or exporting reproduces every original line. When output floods in faster than it can be persisted, the capture applies backpressure instead of dropping lines — the journal stays complete. Rotation is configurable per connection: size per part (default 25 MB) and part count (default 20).

06

Manager, editing, redaction

Tools → Session Journals (Ctrl/Cmd+Alt+J) lists every journal with duration, connection, server, title and entry count; Search contents scans the entries and capture logs of all of them. In the viewer, Edit corrects titles, summaries and markers — a marker you set is never overwritten by the AI. If a secret slipped through anyway, Search & replace rewrites the entries and every capture-log part including the compressed ones, with Count matches as a dry run first.

korTTY session journal manager: journals in a sortable table with duration, connection, server, AI title and entry count, plus description and export actions

The manager: three journals from one afternoon, newest first, with duration, connection, server, AI title and entry count. Running journals are marked and cannot be renamed or deleted while live.

07

Exports that leave the building

PDF with downscaled embedded screenshots, Markdown with a sibling files folder, or the complete HTML bundle as a zip — select several journals and each stays separate inside one archive, optionally AES-256 encrypted. Footer and an optional diagonal watermark are set once under Configuration → Global Settings → Export. Administrators can deny or mandate the whole feature, and a [[rule.session-journal.replace]] policy list redacts patterns such as AKIA[0-9A-Z]{16} on the capture thread — before a matching line is ever written.

11 — Split-screen broadcast

Type once, land everywhere

Split a tab horizontally or vertically, put a different connection in every pane, and flip on broadcast: keystrokes go to all visible panes simultaneously. The fastest way to run one command on three boxes — and the second-fastest way to run it on the wrong three.

korTTY — split view Broadcast on

web-01 · ssh

$ sudo systemctl restart nginx && systemctl is-active nginx
active

web-02 · ssh

$ sudo systemctl restart nginx && systemctl is-active nginx
active

web-03 · ssh

$ sudo systemctl restart nginx && systemctl is-active nginx
active

12 — Themes & designs

Dress the whole app, not just the text

Terminal theme profiles — IntelliJ-inspired presets, live preview, fully editable — stay separate from app designs, which restyle every window and dialog: Default, Matrix Terminal, Holographic Interface, Klingon Tactical, Elegant Dark, Amber CRT, Synthwave '84, Gruvbox Retro, Nord Arctic, Dracula.

On top: terminal-effect plugins per pane — Digital Rain, VHS 1987, Deep Space Radar, or the MU/TH/UR 6000 reference effect — with animated previews and a plugin SPI for writing your own.

Default

ops@prod-web-01:~$ htop
CPU ▕████████░░░░░░░░▏ 48 %
MEM ▕██████░░░░░░░░░░▏ 31 %
ops@prod-web-01:~$

Same session, five designs — colors change, your terminal content doesn't.

korTTY theme settings: color profiles with live preview

13 — Files & snippets

The toolbox around the terminal

An SFTP manager with user/group columns, remote editing through the Snippet Editor, and archive jobs with exclude patterns — next to a Snippet Manager with Monaco highlighting, categories, script arguments, and ZIP/GPG-encrypted exports.

korTTY SFTP Manager: local and remote file panes

korTTY Snippet Editor with Monaco syntax highlighting

The editor is AI-assisted end to end: cursor completion, right-click instructions with diff preview, security checks, and a full code analysis window with flow diagram and PDF export.

Full code analysis: the whole script reviewed, then fixed on your terms

Reviewing a script you inherited usually means reading it line by line and hoping you spot what matters. AI Code → Full code analysis reads the whole snippet at once and comes back with a plain-language summary, its external dependencies, and categorized findings — each with a severity, the exact line, and a concrete recommendation. You tick the ones you agree with; nothing touches your code until you confirm a side-by-side diff.

korTTY Full code analysis: plain-language summary, severity-badged improvements with line numbers, auto-generated flow diagram and hardening options

What this window is doing: a Perl log-parser was analysed with the local profile, and korTTY auto-selected the matching AI skills (Perl, Bourne-Shell) — shown as chips you can override. Left: the summary explains what the script actually does, then OPT-1 flags an unused $host variable on line 24, and two MEDIUM findings propose use autodie instead of manual open/close error handling (line 16) and a UTF-8 encoding layer for non-ASCII log files (line 3) — each with the exact edit to make. Right: a flow diagram generated by its own request, so it stays faithful to the real branches; hover a node to see the source lines behind it. Bottom: eleven hardening options — strict mode, error traps, exit codes, logging, idempotency, dry-run — that get folded into the fixes when you apply them.

01

Findings you can judge, not just accept

Improvements arrive grouped into Security, Optimization and Design, each with a severity badge, the line it affects, why it matters, and the concrete change. Dependencies get their own list with a purpose and a reduce or replace suggestion, tickable separately. The window is non-modal and titled with the file name — keep editing, keep several analyses open side by side.

02

Apply as one reviewed change

Ticked findings, dependency suggestions and hardening options go out as a single request, and the result opens as a before/after diff with changed lines highlighted and a reason card per change. Optionally a saved script header is prepended in the same step. The editor stays untouched until you confirm — a header on its own is inserted without any AI round-trip.

03

A diagram that traces back to the code

The flowchart is a separate, focused request — which produces markedly more faithful diagrams, especially with local models, and lets you read the report while it loads. Hover any node to see the matching snippet lines. Rendering is local: a SHA-256-pinned Mermaid bundle, no Graphviz, no download. Zoom, fit, dark mode, SVG/PNG export and Mermaid-source copy included; automatic generation can be switched off entirely.

04

Reports you can hand to someone else

Export the whole review — summary, findings, dependencies and diagram — as a print-friendly PDF, a single self-contained HTML page, or Markdown with the diagram alongside. The header records the script name, the AI profile that produced it, the date and the skills that were included, so a review stays auditable. Re-run repeats it with a different profile whenever you want a second opinion.

The rest of the editor's AI, briefly

Every action below rewrites only the region you selected and always lands in a before/after preview first. None of them enable internet tools, even on a profile that has access.

Completion

AI Complete

Completion at the cursor, shown as a ghost suggestion you click to insert. Auto-mode requests one whenever you pause — off by default, and only for the current editor session.

Rewrites

Improve one goal at a time

Readability, robustness or performance — one goal per run, no unrelated edits. Robustness and custom instructions can pull in the same hardening options as the analysis.

Security

Security Check

Findings sorted most-severe first, on its own permanently remembered security profile. Hover a changed block in the diff to see which finding it fixes and why.

Comments

Optimize code comments

Explanations inserted where they belong, in the language's own comment syntax, with outdated ones replaced. Executable code stays untouched — and comments follow the editor's Text language, not the UI language.

Prose

Text, translation, descriptions

Spelling correction, translation of a selection, and technical descriptions for a region or the whole snippet — insertable as a comment block. Only comments, strings and user-facing text are rewritten, never logic.

Options

Alternative solutions

Several implementations of the same selection, side by side, each zoomable to full size and regenerable with extra instructions — then apply exactly the one you want.

Banners, because a login screen deserves one

The ASCII Art tool (Ctrl/Cmd+Shift+A) renders text as a FIGlet banner in twelve font styles with a live preview — step through styles with the arrow keys until one fits, then copy it into a login banner, a script header or your docs.

The second tab draws instead of letters: name a subject and an AI profile returns it as an ASCII picture, constrained to printable ASCII within 60 columns and 30 lines so it stays readable in a terminal. New variation redraws the same subject with a different angle, level of detail or line style. Runs on a local profile too — and never uses internet access.

korTTY ASCII Art tool: FIGlet text banner with style picker and live preview

14 — JobScheduler

Automation that survives closed tabs

Schedule background jobs against saved connections and groups — weekdays, fixed times, date ranges, intervals — no terminal tab required. Actions: remote commands, Snippet scripts with argv, SFTP transfers, rsync syncs, headless AI agents, and whole AI swarms with per-job parallelism.

A journal records every run — redacted or full, searchable with wildcards, auto-pruned after 14 days — and korTTY warns before quitting while jobs run, then drains cleanly. Host keys must be pinned before anything runs unattended.

Next: nightly-rsync in 00:14:32

nightly-rsyncRSYNC_SYNC · web-01…0302:00

logrotate-checkAI_AGENT · db-eu-202:30

fleet-patch-auditAI_SWARM · all (16∥, read-only)03:00

backup-etcSFTP_ARCHIVE · web-0103:15

weekly-reportSNIPPET_SCRIPT · jump-hostMon 06:00

The optional menu-bar status: running jobs or a live countdown, plus the next five in the queue.

15 — Security

Paranoid by default. We checked.

Built for people whose servers matter — and audited along the way by pipelines with trust issues.

01

Encrypted at rest

Passwords and SSH-key passphrases live under AES-256-GCM behind one master password. Backups export encrypted — password or GPG. Secret-dependent jobs are blocked while the vault is locked.

02

Host keys, taken seriously

Terminal, SFTP and Mosh share one persistent TOFU store per host:port — default-deny on first use, hard block on key changes. The JobScheduler requires pinned keys before unattended runs.

03

Signed AI supply chain

Local llama.cpp runtimes are source-pinned, rebuilt in a public repo, and selected through a detached-Ed25519-signed index; GGUF downloads pin immutable revisions and verify SHA-256. Sidecars bind to loopback only, behind generated API keys.

04

Your data stays yours

Only the reviewed selection, prompt and agent context go to the model you chose — never whole knowledge stores, never your vault. Telemetry is anonymous, GDPR-compliant, EU-hosted, and off until you say otherwise.

Enterprise policy: one file rules the whole fleet

korTTY is built for automated rollout: deploy the MSI, DEB, RPM or pacman package with whatever you already use — Intune, Jamf, SCCM, Ansible — and drop a single kortty-policy.toml into the installation's policy/ folder next to it. No management server, no directory setup: rules target OS login names and groups, and on domain-joined machines Active Directory groups match automatically. Users can't bypass it — the file is only honored from the admin-writable install directory, and locked settings show up grayed out as "Managed by your organization".

policy/kortty-policy.toml

[meta]
schema-version = 1
organization   = "ACME Corp"            # shown in every "Managed by your organization" hint

[[rule]]                                # no users/groups → the baseline for EVERYONE
name = "company-baseline"
  [rule.servers]
  mode  = "allow"                      # only these servers are reachable — incl. jump hosts, SFTP, jobs
  hosts = ["*.acme.com", "10.0.0.0/8", "vault.acme.com:22"]
  [rule.features]
  ai-swarm = "deny"
  ai-agent-execution = "confirm"       # agent must ask before every mutating command set
  [rule.security]
  enforce-host-key-check = true        # can't be switched off anywhere
  allow-telemetry = false

[[rule]]                                # relax the baseline for one team — AD group, no directory config
groups = ["ACME\\Operations"]
  [rule.features]
  ai-agent-execution = "allow"

[[ai-profile]]                          # provided read-only to every user
id       = "policy-acme-llm"
name     = "ACME internal LLM"
provider = "openai-compatible"
endpoint = "https://llm.acme.internal/v1"
model    = "acme-70b"
api-key-encrypted = "kortty-enc:v1:…"  # korTTY --encrypt-policy-value

A complete, working example: everyone gets an allow-listed fleet, a leashed agent and pinned host keys; the Operations AD group gets the leash taken off; and every user finds a preconfigured company AI profile — key encrypted, marked "Provided by your organization". Precedence is the familiar group-policy pattern: user beats group beats everyone, and among equals the most restrictive value wins.

01

Server lists that mean it

Allow- or deny-lists with host globs (*.prod.acme.com), ports, single IPs, CIDR networks and IP ranges — enforced centrally for terminals, SFTP, QuickConnect, session restore, swarm targets, scheduled jobs and the jump host of every connection. Blocked servers stay visible, grayed out with a lock marker and a clear policy message.

02

Feature switches, down to the agent's leash

Disable AI wholesale or per capability (Agent, Chat, Swarm, Planning), teamwork, plugins, recording, telemetry, update checks. ai-agent-execution knows three modes: allow, confirm — every mutating command set needs interactive approval, auto-approve is defeated — and read-only, where the agent may plan and chat but never executes.

03

Provide, not just forbid

The policy can hand every user finished objects: AI profiles with kortty-enc:v1:-encrypted API keys, admin-provisioned local models (local path or URL, fetched once at startup), immutable script headers and read-only teamwork sources. Updates can point at an internal feed-url instead of GitHub; logs can go to a central directory as JSON for your SIEM.

04

Fails safe, not open

A parse error never silently disables enforcement: an invalid file puts korTTY into fail-safe lockdown — every managed feature denied, no connections — with a startup dialog naming the exact error position. No policy file at all? korTTY behaves exactly as before; the shipped kortty-policy.toml.example is a fully commented template.

16 — Languages

Eight languages built in. The rest, generated.

English, German, Italian, Spanish, Portuguese, French, Croatian and Dutch ship in the box. Need Klingon adjacent? Settings → Translation generates full language files for any language via Google Translate, DeepL, LibreTranslate, Microsoft or Yandex.

korTTY translation settings: generate language files via translation APIs

01

Interface and manual, in your language

Translation isn't limited to the UI: korTTY generates the complete user guide in any language too — via an AI profile or a translation-service API key. The guide's search index is rebuilt in the same pass, so the translated manual stays searchable instead of answering in English.

02

Ask the manual, don't scroll it

The built-in docs assistant answers questions about the guide in plain language — "how do I pin a host key before a scheduled job?" — and answers only from the documentation, never from outside knowledge. Every claim carries a citation link that jumps straight to the relevant guide section; your last ten questions stay one click away.

17 — The obligatory table

Against the usual suspects

All fine tools. None of them puts an agent on your servers.

	korTTY	PuTTY	MobaXterm	iTerm2 + plugins
AI agent working on the server	✓	—	—	—
LLMs in-process (no extra software)	✓	—	—	—
Multi-server AI swarm	✓	—	—	—
Coding-agent management (Claude Code, Codex, Gemini CLI)	✓	—	—	—
Tabs, splits & broadcast input	✓	—	✓	✓
Connection manager with import & export	✓	registry	✓	profiles
Team-shared connections (Git or shared file)	✓	—	team edition	—
Built-in SFTP tooling	✓	psftp CLI	✓	—
Code snippet editor with AI review	✓	—	macros	snippets
Background job scheduler	✓	—	macros	triggers
Auto-documented sessions (AI journal)	✓	log only	log only	log only
Encrypted credential vault	✓	—	master pw	Keychain
macOS · Windows · Linux	✓	Win-first	Windows	macOS
Open source & free	MIT	MIT	freemium	GPL

Our table, our bias — verify everything. The other columns are lovely projects we happily coexist with.

18 — Download

Pick your build. We signed them all.

Direct downloads per platform and CPU — self-contained, trimmed runtime included, no Java installation needed. All assets also on GitHub Releases with Ed25519 signatures.

macOS

DMG / ZIP

Apple Silicon (aarch64) and Intel (x86_64) as separate builds. Metal-accelerated local models.

Apple SiliconDMG ZIP

IntelDMG ZIP

Windows

MSI / ZIP

x86_64 — runs on Windows-on-ARM via x64 emulation. PowerShell, cmd, WSL and Git Bash as local shells.

x86_64MSI ZIP

Linux

DEB / RPM / Flatpak / tar.gz

x86_64 and aarch64, the Flatpak bundle included. Vulkan fallback for local models where the GPU cooperates.

x86_64DEB RPM Flatpak tar.gz

aarch64DEB RPM Flatpak tar.gz

Arch Linux

pacman pkg

.pkg.tar.zst for x86_64 — because you were going to mention it anyway. btw.

x86_64pkg.tar.zst

Migrating? korTTY imports connections from MTPuTTY, MobaXterm and PuTTY Connection Manager — then encrypts them properly.

19 — What's new in v2.17.0

Fresh off the pipeline

2.17

AI pictures in seconds

The ASCII Art tool now asks the model for a small vector drawing and converts it itself, so AI pictures match their subject and arrive in seconds instead of minutes.

2.17

ASCII art from any image

The new Image File tab turns a PNG, JPEG, GIF or BMP into characters, with size, brightness, contrast and invert controls.

2.17

Copy ASCII art as code

Copy as prefixes every line with your language's comment marker, or wraps the picture in ready print statements for 16 languages, from Bash to Rust.

2.17

The tmux cursor stays put

A narrowed scrolling region no longer drags the cursor or scrolls text away, so tmux panes show the cursor on the prompt line again.

Full release notes on GitHub

20 — FAQ

Questions people actually ask

What exactly leaves my machine when I use the AI?

Only the reviewed terminal selection, your prompt, the agent's compact session snapshot, and — if you explicitly assigned a knowledge store to a cloud profile — bounded retrieval excerpts (max six, capped at 4,000 tokens). Never the whole store, never your credential vault. With the integrated local runtime or LM Studio, nothing leaves at all. Internet access for the model is off by default, per profile.

What hardware do local models need?

Less than you'd think: a 4-bit 4B model is ~2.5 GiB and the setup assistant starts it at a conservative 4,096-token context, then verifies it with a real local chat test. macOS uses Metal first; everywhere else CPU with Vulkan fallback. Idle models unload their tensors automatically, so korTTY doesn't squat on your RAM.

What does it cost, and what's the license?

Nothing, and MIT. korTTY is open source by Daniel Mengel; the code, the signed release pipeline and the docs are public on GitHub. Cloud AI usage is billed by your provider under your own API key — local models are free forever.

Agent vs. Swarm — when do I use which?

The Agent works one box: it runs in your active session, plans commands, asks for approval, fixes the thing. The Swarm broadcasts one task to many servers in parallel — including servers without an open terminal — and merges every answer into one comparison table. Rule of thumb: incident on web-01 → Agent; "which of our 40 hosts still runs OpenSSL 1.x?" → Swarm.

I'm coming from PuTTY or MobaXterm. How painful is migration?

One dialog: korTTY imports connections from MTPuTTY, MobaXterm and PuTTY Connection Manager, then stores credentials AES-256-GCM-encrypted behind your master password. Your muscle memory survives — tabs, quick connect (Ctrl+K) and the usual shortcuts are where you expect them.

korTTY is a Java app — do I need to install Java?

No. Every download ships a trimmed Java runtime inside the package, so there is nothing to install, no JAVA_HOME to set, and no version conflict with whatever your system already has. Install the DMG, MSI, DEB, RPM or pacman package and start it like any other native app — the only exception is the optional plain-Java ZIP for people who explicitly want to run it on their own JVM.

Isn't korTTY with all those AI functions too risky for a corporate network?

That is exactly what the enterprise policy is for: one signed TOML file in a machine-owned location decides what the AI is allowed to do — agent execution off, cloud providers denied, only your internal endpoint permitted, the control API forbidden, journal patterns redacted — and nobody can switch it back on locally. A broken policy file locks korTTY down rather than opening it up. Third-party components ride the fast lane for security updates, and anything that stops being maintained gets removed instead of quietly carried along. The rest is deliberately boring: signed releases, a test suite that has to agree before anything ships, and an AI that is optional — the terminal is not.

21 — Open source

Point an agent at it.

korTTY is built in the open — MIT-licensed, signed releases, public docs, and release notes that read like release notes. If it saves your on-call night, a star is the accepted currency.

SSH connect. Prompt. Chill.

The agent doesn't advise. It logs in and does the work.

Shell-native start

Plan first, if you prefer

Transparent runs

Scales to your splits

One question. Your whole fleet answers.

Claude Code is waiting for an answer. korTTY tells you.

Five states, ordered by urgency

Two observations, or nothing

Marked where you already look

A strip in the status bar

The screen stays on this machine

Or let a script do the herding

No Ollama. No LM Studio. No excuses.

Model download

Your runbooks, indexed. Never uploaded.

Teach it your house rules

Chats that render like a lab notebook

A proper terminal first. The brain is a bonus.

Tabs, windows, projects

Local shell, zero network

Comfort where it counts

Logging & replay recording

One terminal that speaks 21 dialects

The session writes its own report

Passwords stay out of it

Follow it live — and fix it live

An AI that keeps minutes

One folder, nothing to install

Logs that stay small

Manager, editing, redaction

Exports that leave the building

Type once, land everywhere

Dress the whole app, not just the text

The toolbox around the terminal

Full code analysis: the whole script reviewed, then fixed on your terms

Findings you can judge, not just accept

Apply as one reviewed change

A diagram that traces back to the code

Reports you can hand to someone else

The rest of the editor's AI, briefly

AI Complete

Improve one goal at a time

Security Check

Optimize code comments

Text, translation, descriptions

Alternative solutions

Banners, because a login screen deserves one

Automation that survives closed tabs

Paranoid by default. We checked.

Encrypted at rest

Host keys, taken seriously

Signed AI supply chain

Your data stays yours

Enterprise policy: one file rules the whole fleet

Server lists that mean it

Feature switches, down to the agent's leash

Provide, not just forbid

Fails safe, not open

Eight languages built in. The rest, generated.

Interface and manual, in your language

Ask the manual, don't scroll it

Against the usual suspects

Pick your build. We signed them all.

DMG / ZIP

MSI / ZIP

DEB / RPM / Flatpak / tar.gz

pacman pkg

Fresh off the pipeline

Coding agents, detected

Control API and kortty-cli

Roll back a runtime

Dialogs open faster

AI pictures in seconds

ASCII art from any image

Copy ASCII art as code

The tmux cursor stays put

Questions people actually ask

Point an agent at it.