Lukan – AI Workstation in a Single Rust Binary

TL;DR

TL;DR: Lukan is an open-source AI workstation you run locally as a single Rust binary — it reads your emails, edits code, manages files, and schedules meetings through a tmux-based terminal UI.

Source and Accuracy Notes

• Official site – lukan.ai
• GitHub – lukan/ai
• HN Show Lukan – Open-source agentic workstation

What Is Lukan?

Lukan is an open-source agentic workstation that puts an AI layer on top of your operating system. It is built entirely in Rust and ships as a single binary with no external runtime dependencies.

The project is designed around three core principles:

• Fully local – Your data never leaves your machine. Lukan runs all its sessions and memory locally.
• Sandboxed and permission-aware – Every action (read email, edit files, run shell commands) requires explicit user approval.
• Session persistence via tmux – Sessions survive terminal closes. You can detach and reattach without losing context.

The architecture is lightweight by design. The core runtime is 32MB with zero garbage collection, giving it a cold start time of approximately 60 milliseconds.

Setup Workflow

Step 1: Install

Lukan is a single Rust binary. Install it via the official method:

# Check the GitHub releases for your platform
curl -L -o lukan https://github.com/lukan/ai/releases/latest/download/lukan
chmod +x lukan
./lukan --version

Step 2: Configure Your LLM Provider

Edit .lukan/config.yaml to point to your preferred model provider:

providers:
  anthropic:
    model: claude-sonnet-4-6
    api_key: $ANTHROPIC_API_KEY
  openai:
    model: gpt-5.4
    api_key: $OPENAI_API_KEY
  local:
    ollama: llama3.2

Lukan also supports Google Gemini and any OpenAI-compatible endpoint.

Step 3: Add Plugins

Enable plugins for the tools you want Lukan to access:

plugins:
  - gmail      # Read and search your inbox
  - calendar   # Create and manage events
  - browser    # Web search and browsing
  - shell      # Run terminal commands

Step 4: Start a Session

ukan tui   # Launch the terminal UI
ukan agent # Start a new agent session

Sessions are managed through tmux, so you can detach and reattach at any time.

Deeper Analysis

Architecture

Lukan’s frontend is a terminal UI that communicates with a Rust-based agent core. The core maintains:

• Memory store – Long-term context that persists across sessions
• Skill system – Pluggable tool integrations (email, calendar, filesystem)
• Worker queue – Background jobs scheduled via cron syntax

Session Model

Unlike browser-based AI agents, Lukan is entirely tmux-driven. Each “pane” in the UI represents an independent agent session. You can have multiple sessions running simultaneously, each with its own model and plugin configuration.

What It Can Do

From the official demo and documentation:

• Email – Search Gmail, draft replies, flag urgent messages
• Calendar – Create events, schedule meetings, send invites
• Code – Read files, edit source code, run tests, search codebases
• Filesystem – Organize downloads, find duplicates, batch-organize files
• Web – Search the web, extract information, compare prices

Comparisons

| Feature | Lukan | OpenAI Agents SDK | LangGraph | |---|---|---|---| | Local execution | Yes | No | No | | Single binary | Yes | No | No | | tmux-based sessions | Yes | No | No | | Gmail integration | Built-in | Plugin | Plugin | | GC-free runtime | Yes | No | JVM/Node |

Practical Evaluation Checklist

• Cold start time: ~60ms (Rust, zero GC)
• Binary size: 32MB core
• Session persistence: tmux-based, survives terminal close
• Permission model: per-action approval dialog
• Plugin ecosystem: Gmail, Calendar, Browser, Shell, custom
• Model support: Anthropic, OpenAI, Google Gemini, Ollama (local)
• Open source: Yes, MIT license

Security Notes

Lukan uses a sandboxed execution model. Every potentially destructive action (sending email, editing files, running shell commands) requires explicit user approval through a confirmation prompt. The tmux-based architecture means sessions are attached to your user session, not a background daemon.

API keys are read from environment variables, never hardcoded in the config file. The config references $ANTHROPIC_API_KEY style variables that your shell resolves at runtime.

FAQ

Q: Does Lukan work on Windows? A: Lukan is primarily developed for macOS and Linux. Check the GitHub releases for platform-specific binaries. The Rust codebase is cross-platform, but the tmux dependency works best on Unix-like systems.

Q: How does it compare to Claude Code or Copilot? A: Claude Code and Copilot are IDE extensions focused on code completion. Lukan is a full workstation agent that operates across your entire OS — email, files, calendar, shell — not just your editor. They serve different use cases and can complement each other.

Q: Can I self-host the models? A: Yes. Lukan supports Ollama for local model inference. Point the ollama provider to your local Ollama instance and you can run entirely without external API calls.

Q: Is my data sent anywhere? A: No. Lukan runs fully local. Unless you explicitly configure a remote API provider, all inference and data storage stays on your machine.

Conclusion

Lukan is a refreshingly simple take on the AI workstation concept — a single Rust binary that puts a capable, permission-gated AI agent on your terminal. The tmux-based session model means you never lose context, and the small footprint makes it practical to run permanently in the background.

If you want a local, self-hosted AI agent that works across your entire OS (not just your code editor), Lukan is worth a look. The project is actively developed and the core architecture is solid.

Links:

• Site: lukan.ai
• GitHub: github.com/lukan/ai