korTTY puts AI agents inside your SSH session — they inspect the box, plan safe commands, ask before anything scary, and fix it. LLMs run in-process; nothing extra gets installed on your machine or your servers.
ops@prod-web-01:~$agent /var is at 94% — find out why and fix it🤖 AI Agent · local/qwen3-4b · cwd: /home/ops→ df -h /var→ du -sh /var/log/* | sort -h | tail -3💭 journald has no size cap — vacuum now, then persist a 200M limit→ sudo journalctl --vacuum-size=200M [approved]✓ /var: 94% → 41%. Root cause: unbounded journald retention.ops@prod-web-01:~$
Live mockup of a real workflow: type agent <task> at any shell prompt — korTTY intercepts it before the shell ever sees it.
v2.7.0
Current release
3
Platforms — macOS · Win · Linux
0 €
Open source, MIT
8
Built-in languages
100 %
Local AI possible
∞
Windows, tabs & sessions
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.
12running3slow9done
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 — 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.
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
Runtimes: llama.cpp and MLX, installed on demandSearch with quantization, license, context and hardware estimateImmutable revision pinned, every byte SHA-256 verified
04 — 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
One store per topic — local HNSW, your embedding modelTest the search before you trust itPer source: sync mode, status, files and chunks indexed
05 — 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
Only skills matching the current request are sent39 built-in skills, editable and exportableHouse rules in plain Markdown — Chat, Agent, or both
06 — 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
Profiles, models, knowledge stores and chats in one windowThe setup assistant does the boring partPause and resume, with live speed and ETA
07 — 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.
08 — 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 viewBroadcast 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
09 — 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
Live preview: foreground, background, cursor, AI coloursFifteen built-in themes, every one editableDuplicate one and make it yours
10 — 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
Local and remote side by side, each with wildcard searchUser, group and permission columnsUpload, download, archive — Edit opens the Snippet Editor
Snippet Editor
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
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
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
11 — 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.
12 — 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 = 1organization = "ACME Corp"# shown in every "Managed by your organization" hint[[rule]]# no users/groups → the baseline for EVERYONEname = "company-baseline"[rule.servers]mode = "allow"# only these servers are reachable — incl. jump hosts, SFTP, jobshosts = ["*.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 anywhereallow-telemetry = false[[rule]]# relax the baseline for one team — AD group, no directory configgroups = ["ACME\\Operations"]
[rule.features]ai-agent-execution = "allow"[[ai-profile]]# provided read-only to every userid = "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.
13 — 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
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.
14 — 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
✓
—
—
—
Tabs, splits & broadcast input
✓
—
✓
✓
Built-in SFTP tooling
✓
psftp CLI
✓
—
Background job scheduler
✓
—
macros
triggers
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.
15 — Download
Pick your poison
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.
Migrating? korTTY imports connections from MTPuTTY, MobaXterm and PuTTY Connection Manager — then encrypts them properly.
16 — What's new in v2.7.0
Fresh off the pipeline
2.7
Full code analysis
The Snippet Editor's AI opens a non-modal analysis window: plain-language summary, dependency review, tickable Security/Optimization/Design improvements, and an auto-generated flow diagram that highlights source lines on hover.
2.7
One local Mermaid renderer
Snippet diagrams, code analysis, workflow generation and AI-chat Mermaid blocks share one SHA-256-pinned Mermaid 11.16 renderer — no Graphviz subprocess, no first-use download.
2.7
Explained security fixes
Security checks now show a side-by-side diff; hovering a changed block names the findings it addresses, with every rationale listed as a card below.
2.7
Transparent terminals, quieter tabs
A 0–100 % background-transparency slider keeps text sharp while the terminal sees through to the desktop — and closing an idle tab finally stops asking if you're sure.
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.
18 — 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.
