jebi — a supercharged AI-native terminal for Mac

brew tap jebi-sh/tap
brew install --cask jebi

Or download directly from jebi.sh.

I've been using terminals for years. iTerm2, Alacritty, Warp — tried them all. They're either fast but barebones, or full-featured but phone home to the cloud.

I wanted something different: a terminal that feels genuinely modern, gives me power-user tools without config hell, and has AI that actually understands my session — without sending anything to an external server.

So I built jebi.

---

The problem with existing terminals

Most terminals haven't changed much in decades. They're fast and reliable, but the UX is stuck in the past — no context about what you're working on, no smart tooling built in.

Warp changed the game visually, but its AI requires a cloud account. For anyone working on sensitive codebases, proprietary code, or just wanting privacy — that's a dealbreaker.

I wanted a terminal that:

• Looks and feels modern out of the box
• Has power-user features without needing plugins or config files
• Has AI built in as a first-class feature — not bolted on, not cloud-dependent

---

Modern UI that doesn't get in the way

jebi is built on xterm.js with WebGL rendering, so it's fast. But the UI layer on top is where it gets interesting.

Split panes and tabs
Open multiple panes in a single window, each running its own shell session. Each tab gets its own accent color — a small thing that makes switching context instantly recognizable.

7 built-in themes
Dark themes that actually look good. Switch instantly from preferences.

Smart prompt segments
The prompt automatically detects your environment and shows relevant context — git branch and status, Node version, Go version, Python virtualenv, Docker context, Kubernetes namespace. No .zshrc gymnastics required.

---

Slash commands — your personal CLI toolkit

This is one of my favourite features. jebi has a built-in slash command system that lets you type / shortcuts directly in the terminal input bar.

Built-in commands include:

• /ls — list files in the current directory, formatted nicely
• /ports — show what's listening on which ports
• /run — run a saved command by name
• /ask — chat with AI about your current session (more on this below)

But the real power is custom slash commands. You define your own in a simple JSON file:

{
  "id": "deploy-staging",
  "name": "/deploy-staging",
  "description": "Deploy current branch to staging",
  "command": "git push origin HEAD && ./scripts/deploy.sh staging"
}

Now /deploy-staging is available in every session. No aliases, no shell functions to maintain — just a command palette that works the way you think.

---

Local AI — no API key, no subscription, nothing leaves your machine

The AI in jebi runs entirely on-device via llama.cpp. No account required, no data sent anywhere.

There are three ways AI shows up:

1. Error explanations
When a command fails, jebi analyses the output and explains what went wrong in plain English — with context about your git state, language runtime, and environment.

2. Command suggestions
After every command runs, jebi suggests the next 3 commands based on what you just did and where you are. Not generic completions — contextual suggestions that understand you just ran git push and might want to open a PR next.

3. /ask — chat about your session
Type /ask why is my docker container crashing and the AI has access to your recent terminal output, current directory, git branch, and environment. It answers with that context, not just from general knowledge.

All of this runs on models like Qwen2.5 1.5B or Phi-3 Mini — small enough to run on a MacBook without a GPU, fast enough to not interrupt your flow.

---

How it's built

The stack is a bit unusual:

• Go — PTY server (term-core) that manages shell sessions over WebSocket, handles AI dispatch, detects environment context
• Electron + React — the app shell and UI layer
• xterm.js — terminal rendering with WebGL
• llama.cpp — local inference, managed as a subprocess by the Go core

The Go core and Electron communicate over WebSocket. When you run a command, the shell output streams to xterm.js, and a copy goes to the AI pipeline for analysis.

Environment detection happens in Go — it reads git status, checks for package.json, go.mod, Dockerfile, kubeconfig, etc. and builds a context banner that gets prepended to every AI prompt. That's what makes suggestions feel relevant instead of generic.

---

The hard parts

Honest reflection on what was tricky to get right:

Useful suggestions vs. noise
Early versions would suggest things like cd0c36c..bf21455 main -> main — literally git output lines, not commands. Getting the model to understand "only suggest things I can actually type into a shell" took a lot of prompt work and explicit bad-output examples.

Qwen3 thinking mode
When I added Qwen3 models, nothing worked. Turned out thinking = 1 was consuming the entire context window before generating any output. Fixed with --reasoning off flag on the llama-server, which disables the think-block generation for faster, leaner responses.

Context without latency
The AI needs enough context to be useful, but building and sending that context on every keystroke would be too slow. The solution: detect context once when the session starts, update it when the directory changes, and include a rolling window of recent output — not the full history.

---

What's next

jebi is early — I'm calling it beta for a reason. Here's what I'm actively working on:

• More model options (including larger, higher-quality models for when you have the RAM)
• Windows and Linux support
• Smarter /ask with multi-turn conversation
• AI-powered command search across your history
• More built-in slash commands

---

Try it

jebi is free. Source available under FSL-1.1 (you can read, fork, contribute).

macOS, Apple Silicon + Intel.

brew tap jebi-sh/tap
brew install --cask jebi

Or download directly from jebi.sh.

---

Would love to hear what would make this genuinely useful in your daily workflow. What do you wish your terminal could do?