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.

AI Manager — Local Models

AI Manager ×

ProfilesLocal ModelsKnowledge StoresAI SkillsLocal AI

Run local models (GGUF via llama.cpp, MLX on Apple Silicon) directly in korTTY with isolated servers. Select several installed models to start them in parallel.

Runtimes

Runtime	Version	Backend	State
llama.cpp	b6123	Metal	✓ Installed · signature verified
MLX	0.26.1	MLX	✓ Installed

Installed local models

Name	GGUF file	Purpose	Backend	Unload after	State
Qwen3-8B	Qwen3-8B-Q4_K_M.gguf	Chat	llama.cpp	15 min	● Running · :41873
nomic-embed-text	nomic-embed-text-v1.5.f16.gguf	Embedding	llama.cpp	never	Stopped
Qwen3-4B	Qwen3-4B-Q4_K_M.gguf	Chat	llama.cpp	15 min	Installed

✦ Setup assistantImport GGUFConfigure▶ Start selected■ Stop selectedRemove⟳ Refresh

Find local models on Hugging Face

qwen3GGUF + MLX⌕ SearchLoad more

Repository	Format	Quantizations	License	Size	Context	Hardware
bartowski/Qwen_Qwen3-4B-GGUF	GGUF	Q4_K_M · Q5_K_M · Q8_0	apache-2.0	2.5 GiB	40960	Comfortable
unsloth/Qwen3-8B-GGUF	GGUF	Q4_K_M · Q6_K	apache-2.0	5.0 GiB	40960	Comfortable
Qwen/Qwen3-14B-GGUF	GGUF	Q4_K_M	apache-2.0	9.0 GiB	40960	Tight
mlx-community/Qwen3-4B-4bit	MLX	4bit	apache-2.0	2.3 GiB	40960	Comfortable

QuantizationQ4_K_M⇣ Download and install

Model download

Repository: bartowski/Qwen_Qwen3-4B-GGUF · Quantization: Q4_K_M · revision 3f2a9c1

Downloading: Qwen3-4B-Q4_K_M.gguf (1/1)

0.0 GiB of 2.5 GiBPauseCancel

Runtimes: llama.cpp and MLX, installed on demandSearch with quantization, license, context and hardware estimateImmutable revision pinned, every byte SHA-256 verified

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.

AI Manager — Knowledge Stores

AI Manager ×

ProfilesLocal ModelsKnowledge StoresAI SkillsLocal AI

Create a local knowledge store by choosing files or a folder. korTTY previews and filters supported text content before indexing it; HNSW details are managed automatically.

Knowledge stores

Name	Type	Embedding model	Used for	Sources
Operations handbook	Local HNSW	qwen3-embedding	Chat, Agent	2
Runbooks (prod)	Local HNSW	nomic-embed-text	Agent	3
Perl & shell style	Local HNSW	qwen3-embedding	Text / translation, Coding	1

Create knowledge storeConfigureDelete storeTest searchRefresh

Test searchOperations handbook · top 3 of 6 allowed excerpts

Search

0.82

runbooks/nginx.md § Log rotation

Rotate with logrotate daily, keep 14, compress; reload nginx with systemctl reload nginx — never restart.

0.77

handbook/oncall.md § Disk alerts

If /var is above 85 %, check /var/log/nginx before anything else.

0.64

runbooks/logrotate.conf

/var/log/nginx/*.log { daily rotate 14 compress delaycompress }

Sources

Path	Type	Sync	Status	Files / chunks	Skipped	Last indexed
~/ops/handbook	Folder	Watch	READY	38 / 1,204	2	2026-07-28 09:12
~/ops/runbooks	Folder	Manual	READY	48 / 1,312	1	2026-07-15 20:30

Add filesAdd folderUpdate nowCancelSync modeAdvancedEnable / disableRemove

One store per topic — local HNSW, your embedding modelTest the search before you trust itPer source: sync mode, status, files and chunks indexed

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.

Settings — AI Skills

AI Manager ×

ProfilesLocal ModelsKnowledge StoresAI SkillsLocal AI

Enable AI SkillsAutomatically send only matching skills

SortShow hidden

Search skills…

Bourne-Shell (sh, POSIX)Both · Enabled · Built-insent

Dart (Flutter)Both · Enabled · Built-insent

DockerBoth · Enabled · Built-insent

Go (Golang)Both · Enabled · Built-insent

House rules: deployBoth · Enabled · Customsent

Java (JVM)Both · Enabled · Built-insent

KotlinBoth · Enabled · Built-insent

Perl (Perl 5)Both · Enabled · Built-insent

PHPBoth · Enabled · Built-insent

PythonBoth · Enabled · Built-insent

RubyBoth · Enabled · Built-insent

SQLBoth · Enabled · Built-insent

TerraformBoth · Enabled · Built-insent

Total: 40 · Active: 40 · Inactive/hidden: 0

+ AddImportExport

Chat request:

Skill namePerl (Perl 5)

Tagsperl code, cpan, perldoc

TargetBothActive

1# Perl Best Practices

2

3When generating or reviewing Perl (Perl 5) code, apply the rules below.

4

5## Robust Perl Code

6

7- Start every file with `use strict;` and `use warnings;`.

8- Open files with three-argument `open` and a lexical filehandle.

9- Include `$!` in every error message.

10- Report misuse with `Carp::croak` instead of `die`.

11- Validate `@ARGV` up front; exit non-zero on failure.

Ready

Only skills matching the current request are sent39 built-in skills, editable and exportableHouse rules in plain Markdown — Chat, Agent, or both

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.

Tools — AI Manager

AI Manager ×

ProfilesLocal ModelsKnowledge StoresAI SkillsLocal AI

Profiles decide which model answers Chat, Agent, Swarm and the editor tools.

Profile	Provider
★ Claude Sonnet	Anthropic
GPT-5 mini	OpenAI
Local · Qwen3-8B	korTTY local
🔒 ACME internal LLM	Provided by your organization
Local · Qwen3-4B	korTTY local

+ AddEditDuplicateSet default✦ Setup assistant

Used for

ChatAgentSwarmSnippet EditorJournal

✦ Setup assistant — local modelStep 1 of 5

1

Check this computer

Apple M3 Pro · 36 GB unified memory · Metal

2

Install the runtime

llama.cpp b6123 · source-pinned, signature verified

3

Choose a model

Qwen3-4B · Q4_K_M · 2.5 GiB · hardware estimate: Comfortable

4

Download and verify

SHA-256 checked against the pinned revision

5

Create a profile

“Local · Qwen3-4B” for Chat and Agent

Downloading Qwen3-4B-Q4_K_M.gguf

PauseCancel

BackNext

Ready

Profiles, models, knowledge stores and chats in one windowThe setup assistant does the boring partPause and resume, with live speed and ETA

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 — Logfile Manager

Every log korTTY ever wrote, in one window

Since v2.20.0, Tools → Logfile Manager… (Ctrl/Cmd+Shift+X) collects the files terminal logging has written: from the default folder, every saved connection's log folder, every folder a logger has ever written into and the folders you add. Filter by name, time range, format or compression, check each file's size and the first day retention may delete it, then view, export or delete. A file that is still being written is marked live: you can view it, but not export or delete it.

Logfile Manager

Log files written by KorTTY's terminal logging

⟳ RefreshView⤓ Export…BadgesDeleteOpen folder+ Add folder…

SearchFile, connection, server or badgeFrom▦HH:MMTo▦HH:MMTypeAllCompressionAllClear filters

File name	Connection name	Badges	Started ▾	Size (MB)	Type	Compression	Deletable from
2026-10-13-17-46-47-web01_1.json.gz	Web Server	HoldRelease review	13.10.2026 17:46:47	0.42 MB	JSON	gzip	—
2026-10-13-16-02-11-db01_1.xml.gz	Database	IncidentHold	13.10.2026 16:02:11	1.86 MB	XML	gzip	13.11.2026
2026-10-13-14-30-12-web01_2.log	Web Server		13.10.2026 14:30:12	0.08 MB	Plain Text	none	—
2026-10-13-11-05-40-ci01_1.log.zst	Build Host	Done	13.10.2026 11:05:40	0.31 MB	Plain Text	zstd	—
2026-10-13-09-12-03-jump_1.loglive	Jump Host		13.10.2026 09:12:03	2.14 MB	Plain Text	none	—
2026-10-12-22-15-09-web02_1.log.gz	Web Server	Review	12.10.2026 22:15:09	0.97 MB	Plain Text	gzip	12.11.2026
2026-10-12-07-58-31-web01_1.log.gz	Web Server		12.10.2026 07:58:31	9.71 MB	Plain Text	gzip	12.11.2026
2026-09-30-03-00-00-db02_1.json.bz2	Database		30.09.2026 03:00:00	3.20 MB	JSON	bzip2	—
2026-09-14-10-00-00-db01_1.log.gz	Database		14.09.2026 10:00:00	0.66 MB	Plain Text	gzip	15.10.2026
2026-08-02-21-40-00-ci01_1.log	Build Host		02.08.2026 21:40:00	50.79 MB	Plain Text	none	—

10 of 10 files · 70.1 MB · 1 liveClose

Searches file names, folders, connections, server addresses and badge namesPins badges to the selected logs; Hold keeps a file safe from retention and DeleteStill being written: it can be viewed, but not exported or deleted

What this window shows: ten logs from four saved connections, newest first, in every format and compression the manager recognises. Searching review also matches badge names: the preset Review and a custom Release review. Pinning Hold to the database's incident log turns its Deletable from date into a dash, so retention leaves it alone. The jump-host session is still being written, so Export and Delete are greyed out.

01

Finds its own logs and ignores everything else

Only files whose names korTTY generates are listed, plain or compressed with gzip, zstd or bzip2, so a folder you share with other tools stays untouched. Because the manager remembers every folder a logger has written into, logs from Quick Connect sessions and from connections deleted since still turn up. A time range matches every file that overlaps it: a session from 08:00 to 09:30 is listed for 09:00–09:30. Deletable from shows the first day the retention sweep may remove a file; files it never deletes show a dash.

02

A viewer that never loads the whole file

View reads only the lines on screen, so a log of several hundred megabytes opens without filling memory; a compressed log is unpacked into a private temporary copy that is deleted when the viewer closes. Ctrl+F searches, Go to line jumps, and up to 2,000 selected lines copy at once. Links, e-mail addresses and paths are underlined (a click copies them, nothing is opened), and a keyword-highlighting set colours errors and warnings. JSON and XML logs open formatted, with a switch back to the raw lines; a live log is shown as a snapshot with a Refresh button.

03

Badges, and one that means it

Select logs, choose Badges and pin Hold, Review, Incident, Important, Done or Share, or a badge of your own: up to 40 characters, a colour, one of 30 symbols and one of five styles. Badges are searchable and live in hidden sidecar files beside the log, so they survive gzip compression. Only Hold changes behaviour: automatic retention and Delete both skip the file until Hold is removed. Delete asks first and lists uncompressed files separately, because another running korTTY could still be writing them.

04

Exports you can trim, convert and lock

Export whole logs or only the lines selected in the viewer, optionally trimmed to a time range. The content format (unchanged, plain text, XML or JSON) is chosen independently of the archive (none, zstd, gzip, bzip2 or ZIP), so a JSON log can leave as XML inside a gzip archive. ZIP archives can carry an AES-256 password, and any archive can additionally be encrypted with GPG for a key from GPG Key Management. Exports run in the background with progress and cancel; a failed or cancelled export leaves no partial file, and export passwords are never saved.

05

Who, where, and on which server

A saved connection can write the SSH username and the working directory into every log line, as the full path or relative to the first directory the session reported. Both are captured before buffering and pass through the secret redactor, and an enterprise policy can mandate either setting. In the list, servers known only by IP address get a stable alias from 10,000 generated names, with the recorded address on hover; an address an old log never recorded is shown as unknown instead of being looked up in DNS.

11 — 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.

Session Journal — Web Server — Checked and reloaded nginx

Open in browserExportEditAppearance⟳ RefreshAI Q&ALive

Web Server — Checked and reloaded nginx

deploy@web01.example.com:22

Routine maintenance session on web01.example.com.

STARTED

2026-08-03 18:29

DURATION

27m 0s

ENTRIES

2

COMMANDS

3

ERRORS

1

SCREENSHOTS

0

⇥◆⌕A−A+◐

2026-08-03

18:29

InfoConnected and checked the service

Opened the session and looked at the nginx unit; the service was running.

$ systemctl status nginx

19:11

ImportantFound a missing-file error and reloaded nginx

The error log showed a missing document root; the configuration was fixed and reloaded. The service stayed available throughout.

$ tail -n 20 /var/log/nginx/error.log
$ systemctl reload nginx

2026/08/03 10:13:02 [error] 812#812: *4 open() "/var/www/x" failed (2: No such file)
nginx.service — Active: active (running) since Mon 2026-08-03 09:58:11 CEST

19:24

Info

Created with korTTY · github.com/chardonnay/korTTY

Header counts entries, commands, errors and screenshotsAI title, summary and the marker it suggestedCommands in green, output in blue — click for the raw log

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.

Session Journals

Filter by title, connection or hostSearch contentsAI search

nginxweb01.example.commissing-file errorcertbot

Started	Duration	Connection	Server	Title	Entries
03.08.2026 19:02	● 6m	Web Server	deploy@web01.example.com	Web Server — Rotating nginx logs	3
03.08.2026 18:29	27m 0s	Web Server	deploy@web01.example.com	Web Server — Checked and reloaded nginx	8
03.08.2026 16:36	12m 0s	Database	dbadmin@db01.example.com	Database — Disk almost full on the data volume	6
03.08.2026 14:01	6m 0s	Build Host	ci@ci01.example.com	Build Host — Ran a clean build	6
02.08.2026 22:15	41m 12s	Web Server	deploy@web02.example.com	Web Server — Certificate renewal (certbot)	11
02.08.2026 09:48	3m 40s	Jump Host	ops@jump.example.com	Jump Host — Checked sshd config	2
01.08.2026 17:20	18m 05s	Database	dbadmin@db02.example.com	Database — Vacuum and reindex	9

OpenRenameExportDeleteOptions⟳ RefreshPDF · Markdown · HTML bundle

Description

Routine maintenance session on web01.example.com.

Save descriptionClose

Filter by title, host or user — or search inside every journalExport as PDF, Markdown or a complete HTML bundleA description per journal, searchable and in every export

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.

12 — 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

13 — 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.

Settings — Themes

Global Terminal Settings

FontColorsThemesAppearanceTerminalVideoBackupLoggingUpdatesWindowSecuritySFTP ManagerEditor

Terminal Themes

Create and manage color themes. Select a theme in the connection settings or Quick Connect dialog.

When enabled, applying a theme also changes font family and size.

Default (built-in)

Dark Mode (built-in)

IntelliJ Darcula (built-in)

IntelliJ Light (built-in)

Fleet Dark (built-in)

Fleet Light (built-in)

One Dark (built-in)

Monokai (built-in)

Solarized Dark (built-in)

Solarized Light (built-in)

Nord (built-in)

GitHub Dark (built-in)

GitHub Light (built-in)

High Contrast Dark (built-in)

Dracula (built-in)

AddEditDuplicateDelete

Theme Preview

AaBbCcDdEe 0123456789 GitHub Dark

FGBGCURSORAI BGAI RUNAI ERR

daniel@web01:~/sites$ ls -la

drwxr-xr-x 5 daniel staff 160 Jul 28 conf.d

-rw-r--r-- 1 daniel staff 3.4K Jul 28 nginx-site.conf

-rwxr-xr-x 1 daniel staff 2.1K Jul 25 deploy.sh

daniel@web01:~/sites$ sudo nginx -t

nginx: [warn] "ssl_stapling" ignored, no resolver

nginx: [emerg] unknown directive "server_nmae"

✦ AI: line 14 — did you mean server_name?

daniel@web01:~/sites$

CancelSave

Live preview: foreground, background, cursor, AI coloursFifteen built-in themes, every one editableDuplicate one and make it yours

14 — 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.

SFTP Manager

[Produktion] daniel@10.211.55.5SFTP: daniel@10.211.55.5 ×

Local System

Path:/Users/daniel↑ ⌂

Search:Search files… (* as wildcard)

Name	Size	Date	User	Group	Perms
▰.config	—	2026-07-10 14:02	daniel	staff	drwxr-xr-x
▰.kortty	—	2026-07-28 11:40	daniel	staff	drwx------
▰.ssh	—	2026-06-02 09:15	daniel	staff	drwx------
▰Desktop	—	2026-07-28 08:31	daniel	staff	drwx------
▰Documents	—	2026-07-09 17:20	daniel	staff	drwx------
▰Software-Projects	—	2026-07-28 16:05	daniel	staff	drwxr-xr-x
▭backup-2026-07.tar.gz	148,2 MB	2026-07-27 23:00	daniel	staff	-rw-r--r--
▭deploy.sh	2,1 KB	2026-07-25 10:12	daniel	staff	-rwxr-xr-x
▭nginx-site.conf	3,4 KB	2026-07-28 16:44	daniel	staff	-rw-r--r--
▭.gitconfig	62 B	2026-07-20 09:03	daniel	staff	-rw-r--r--
▭.zshrc	38 B	2026-07-10 14:02	daniel	staff	-rw-r--r--

Remote Server: 10.211.55.5

Path:/home/daniel↑ ⌂

Search:Search files… (* as wildcard)

Name	Size	Date	User	Group	Perms
▭nginx-site.conf	3,4 KB	2026-07-28 16:45	1000	1000	-rw-r--r--
▰.ansible	—	2026-06-17 21:10	1000	1000	drwxr-xr-x
▰.config	—	2026-06-25 12:44	1000	1000	drwxr-xr-x
▰.ssh	—	2026-02-24 08:00	1000	1000	drwx------
▰Dokumente	—	2026-07-17 15:31	1000	1000	drwxr-xr-x
▰Scripts	—	2026-04-30 10:22	1000	1000	drwxr-xr-x
▭app.conf	1,8 KB	2026-07-12 09:41	1000	1000	-rw-r--r--
▭redis.conf	92,4 KB	2026-05-03 18:07	1000	1000	-rw-r-----
▭.bash_history	22,4 KB	2026-07-26 07:55	1000	1000	-rw-------
▭.bashrc	522 B	2026-07-23 06:10	1000	1000	-rw-r--r--
▭lion	3,9 KB	2026-05-05 13:20	0	0	-rw-r--r--

⇡Uploading nginx-site.conf → /home/daniel0%

Local System⟳ RefreshDeleteRightsRemote⟳ RefreshDeleteRights⇡ Upload⇣ DownloadArchiveEdit

Connected to daniel@10.211.55.5 (10.211.55.5) — SSH over TCP/IP

Local and remote side by side, each with wildcard searchUser, group and permission columnsUpload, download, archive — Edit opens the Snippet Editor

Snippet Editor

Edit Snippet — server_load_table.pl ×

Nameserver_load_table.pl

Code languageperlText languageEnglish (en)CategoryMonitoring

Tagsload, monitoring, table

Description✨ AI suggestion✨ Correct spelling

Content:Edit✨ Format Code✓ Check Syntax✨ AI Text✨ AI Code→ One-linerA−14ptA+

AI skills:2 selectedPerl (Perl 5)House rules: deploy

1#!/usr/bin/perl

2# server_load_table.pl — current and historical load averages

3

4use strict;

5use warnings;

6use POSIX qw(strftime);

7

8sub get_load_average {

9 my $file = '/proc/loadavg';

10 open(my $fh, '<', $file) or return (undef) x 3;

11 my $line = <$fh>;

12 close($fh);

13

14 return (split /\s+/, $line)[0..2];

15}

16

17my ($m1, $m5, $m15) = get_load_average();

18printf "%-8s %6.2f\n", $_->[0], $_->[1] for (['1 min', $m1], ['5 min', $m5]);

Available placeholders: ${date}, ${time}, ${hostname}, ${username}, ${clipboard}, ${cursor}

CancelOKSave as new snippet

Ready

AI writes the description, and corrects the spellingAI Text and AI Code: every action from this toolbarChoose which skills apply to this snippet

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.

AI Code Analysis — messages_errors_table.pl

AI Code Analysis — messages_errors_table.pl ×Edit Snippet — messages_errors_table.pl

What the script does, its dependencies and improvements. Tick the improvements to apply.

AI skills:(auto-selected)Perl (Perl 5)Bourne-Shell (sh, POSIX)Select…

Profile: localAI profile:Default profileRe-runSelect all improvementsA−14ptA+Copy to ClipboardExport

The script reads a system log file (default /var/log/messages), parses each line into host, process and message, classifies the severity (CRITICAL, ERROR, WARNING), normalizes hex values, IP addresses and numbers to placeholders, aggregates identical messages by signature and prints a table sorted by count, severity and process.

Dependencies (2)

POSIX strftime — core module, keepGetopt::Long — core, could replace manual @ARGV parsing

⚡ Optimization (1)

LOWOPT-1Eliminate unused variable $hostLine 24

parse_syslog_line returns a host value that the script never uses.

Recommendation: my (undef, $process, $message) = parse_syslog_line($line);

● Design (2)

MEDIUMSEC-1Replace manual open/close error handling with autodieLine 16

Recommendation: add use autodie; and drop the explicit or die on lines 16 and 38.

MEDIUMSEC-2Ensure proper handling of Unicode log filesLine 3

Recommendation: insert use open qw(:std :encoding(UTF-8)); after the pragmas.

Flow diagramGenerate automatically

✨ RegenerateDark mode: DarkSave SVGSave PNGCopy Mermaid−108%+Fit

Start

Read configured values

Parse each line → host, process, message

Normalize & aggregate by signature

Log file readable?

yes

Print sorted table

no

Warn and exit 2

Stop

lines 18–31

Script header:No headerApply improvements

▾ Hardening options (11)

Strict mode (abort on error)Error trap & cleanupMeaningful exit codesLogging (--verbose)Configuration block for literalsFinal summaryStyle-guide / linter cleanPrecondition checksIdempotency (skip completed steps)Safe mode (--dry-run + confirm)--help & argument parsing

Loaded text file: /home/daniel/Dokumente/messages_errors_table.pl

Skills auto-selected for the language, shown as chipsSeverity, ID and the exact line — OPT-1, line 24Flow diagram from its own request; hover a node for its lines

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.

ASCII Art

Text BannerAI Picture

Style:◀standard▶1 / 12

Text:

Zoom:−100 %+⟲Copy to Clipboard

Close

Second tab: name a subject, the AI draws it in ASCIITwelve FIGlet styles — step through with the arrow keysCopy straight into a login banner or script header

15 — Security: session isolation

One tab crashes. The other nine don't notice.

Since v2.19.0 korTTY can keep a terminal session apart from itself and from every other tab — per connection, per folder or as the default: None, Own process, or Own process + sandbox. Each tab wears a shield that says what the session actually got, and an incognito session leaves no trace in korTTY at all.

Session isolation Own processSandboxIncognito

korTTYmain process

web-01Own process

db-eu-2Own process + sandboxReconnect

local · zshno log · no journal · no recording

vault · master.keySSH keys · known_hostssigns on request

127.0.0.1 · one-time tokenworkerreaches

session workerpid 48211 · ssh

web-01.acme.com:22

sandbox · self-test ✓

session workerpid 51877 · ssh

db-eu-2.acme.com:22only this port

sandbox · self-test ✓

zshKORTTY_SANDBOX=1

~/proj · $TMPDIRwrites only here

Each isolated session gets a worker of its own, connected to korTTY over 127.0.0.1 with a one-time token and a pinned key.

The server wants a signature. The worker asks korTTY, korTTY signs — the private key never leaves home.

Inside the sandbox, ~/.ssh, ~/.kortty, ~/.gnupg and the keychains are simply not there.

A worker crashes. Its tab offers to reconnect; every other tab keeps running.

Reconnected: a fresh worker, a fresh token, nothing else disturbed.

Animated diagram: korTTY keeps the keys and the vault; every isolated session runs in a worker of its own, the sandboxed ones behind the operating system's walls.

01

One worker per session

An isolated SSH or built-in Mosh session runs in a session worker, a small process korTTY starts for this one connection. It connects, authenticates, holds the encrypted link and passes every channel through, so the terminal, SFTP, file drops, agent commands and -L/-D/-R tunnels work as before. If it crashes, the tab says Session process crashed with its last message and offers to reconnect. Tools → Session Processes… lists every worker with memory, CPU and uptime and ends one on request; workers run at lower priority, so a busy one never slows the window.

02

A sandbox that has to prove itself

With Own process + sandbox the session runs inside the operating system's sandbox — sandbox-exec on macOS, bubblewrap on Linux. It can't read or write ~/.kortty (connections, credentials, master.key, logs, journals), ~/.ssh, ~/.gnupg or the keychains, and writes only to its working folder, the temp folder and a folder of its own that disappears with the session. Before the first sandboxed session korTTY checks that a secret file really is unreadable from inside. Only a sandbox that passes counts.

03

Keys stay home, the network stays narrow

A worker never receives a private key: when the server asks for a signature, korTTY signs. It never sees the vault or the master password either. In the sandbox a macOS worker may only reach the ports of the server and the jump server; on Linux it has no network of its own at all, and korTTY opens exactly those connections for it. Remote tunnels come back through korTTY, which connects the local target itself.

04

Strict terminal mode

Escape sequences a hostile server could misuse are dropped before the terminal sees them: clipboard writes (OSC 52), links that aren't http or https (OSC 8), oversized or control-laden window titles, OSC sequences over 4 KiB, and DCS, APC, PM and SOS strings. Colours, shell-integration marks and the working directory pass unchanged. On automatically inside a sandbox.

05

Incognito sessions

File → New Incognito Session… opens a tab korTTY forgets: no terminal log, no journal, no recording, no Recently Closed entry, nothing in a saved project, no restore after a restart. The tab shows a spy, and incognito combines with every isolation level. It covers what korTTY writes down — the server and the remote shell's own history are another matter.

06

And for the admins

An enterprise policy can demand a minimum with [rule.isolation] minimum and forbid incognito with incognito-sessions = "deny". Lower levels grey out everywhere, and a session that can't get the minimum is refused instead of quietly opened with less. Windows and the Flatpak package have no sandbox yet; the tab shows an amber shield rather than pretending.

16 — 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.

17 — 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.

18 — 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.

Settings — Translation

Global Terminal Settings

UpdatesWindowResourcesSecurityPrivacySFTP ManagerEditorLanguageTranslation

System language:English

Translation API:Google Translate

API Key:••••••••••••••••••••••••

Test API Connection✓ Connected

Target language:Kiswahili (sw)

Generate Language File

Generated languages:

Polski (pl) · 2,086 strings

Türkçe (tr) · 2,086 strings

Kiswahili (sw) · 2,086 strings

Guide translation

Translates the built-in guide into the target language. On a local AI model this runs for several hours; it can be cancelled at any time and continues where it stopped.

AI profile:Local · Qwen3-8BEstimate duration≈ 3 h 10 min

Chapter 9 of 38 — Session isolation

PauseCancelresumes where it stopped

Translated guides:Deutsch (de) ✓Español (es) ✓

CancelSave

Google Translate, DeepL, LibreTranslate, Microsoft, YandexOne click writes a complete language fileGuide translation runs on an AI profile — resumable

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.

19 — 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.

20 — 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.

21 — What's new in v2.25.0

Fresh off the pipeline

2.25

AI memory

AI chat and the agent remember what matters — globally and per connection, as plain Markdown files you can read and edit.

2.25

Rules learned into skills

korTTY suggests a rule when you say something should stick, and saves it to the memory or a skill only after you confirm.

2.25

Skill statistics

See how often each skill is used, how big it has grown, and let the AI propose a shorter version.

2.25

Kilo CLI recognised

The Coding Agents panel now follows Kilo too: working, waiting for your answer, or idle at its prompt.

Full release notes on GitHub

22 — 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.

23 — 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

Every log korTTY ever wrote, in one window

Finds its own logs and ignores everything else

A viewer that never loads the whole file

Badges, and one that means it

Exports you can trim, convert and lock

Who, where, and on which server

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

One tab crashes. The other nine don't notice.

One worker per session

A sandbox that has to prove itself

Keys stay home, the network stays narrow

Strict terminal mode

Incognito sessions

And for the admins

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