What Is PeekMe? The Beginner's Guide to Inline Text Explanations in Terminal Coding Agents

CodexFuse Team · 2026-11-05T10:43:31.234Z · 18 min read min read

What Is PeekMe? The Beginner's Guide to Inline Text Explanations in Terminal Coding Agents

PeekMe is a small open-source Rust tool that explains text inside terminal coding agents. Select any words in your agent's output, press Alt+P, and a short explanation opens right under the selected text, inside the terminal.

The other lines move down to make room, just like Peek Definition in VS Code, and Esc closes the box. This guide explains what PeekMe is, how it works, which agents it supports, and how to install it.

What Is PeekMe?

PeekMe is a free, open-source command-line wrapper that sits in front of a terminal coding agent and explains selected text inline. It works with Claude Code, Codex CLI, Pi, GitHub Copilot CLI, and Kiro CLI as of version 0.7.0, published October 24, 2026. You install it once, and the same keys work in every supported agent.

The idea is simple enough to describe in one line. You are reading an agent's answer in the terminal, you select an unfamiliar phrase with the mouse, and you press Alt+P.

A small box opens under the selection with a short explanation from the chat's own model, and the model knows the conversation, so a phrase like "its split panes" in an answer about the Kitty terminal gets explained as Kitty's split panes. Press Esc and the screen returns to exactly how it was.

Terminal coding agents answer in long walls of text, and sooner or later one of them mentions a flag, a library, or a concept you do not recognize. The usual fix is to copy the term, paste it into a new question, and wait for a fresh answer.

PeekMe removes that round trip by putting the explanation where your eyes already are. If you hash out data before pasting it anywhere, the SHA-256 hash generator is a handy companion, and if you run agents on a remote machine, VPS hosting is the usual home for that setup.

PeekMe is not a VS Code extension and it does not run inside an editor. It borrows the inline-expansion idea from VS Code's Peek Definition and brings it to the terminal, where coding agents actually print their answers. The project is young: the GitHub repository was created on September 26, 2026, and it reached version 0.7.0 just 28 days later, on October 24, 2026.

How Does PeekMe Work? Select, Press Alt+P, Read the Explanation Inline

PeekMe explained in one sentence: it starts your coding agent inside a pseudo-terminal and watches the output pass through. Every byte the agent prints goes to your screen unchanged, and the same bytes also go to a terminal emulator that lives in memory, so PeekMe always knows exactly what is on your screen. When you press Alt+P, it finds your selection on that in-memory screen and asks the agent's own model to explain it.

The full flow takes five steps from a cold terminal to your first explanation:

1. Install PeekMe once with npm, Homebrew, Cargo, or the shell installer, then run peekme install.
2. Open a new terminal and start your agent exactly as always, for example claude, codex, pi, copilot, or kiro-cli.
3. Read the agent's answer and select any unfamiliar text with the mouse.
4. Press Alt+P on Linux or Option+P on a Mac to open the explanation box under the selection.
5. Read the short answer, then press Esc to close the box and return to the chat.

Nothing starts before the first Alt+P. PeekMe does nothing until you ask for an explanation, and the agent itself runs exactly as it would without the wrapper. If you ever want one plain session, run command claude or the equivalent for your agent, and PeekMe stays out of the way.

Peek vs Ask: What Alt+P and Alt+Q Each Do

PeekMe Alt+P and Alt+Q are the two core keys, and they answer different needs. Alt+P, called Peek, explains the selection for you, with no typing at all. Alt+Q, called Ask, opens the same kind of box empty, so you can type your own question about the selection first.

Peek is for the moments when you only need a definition. The model gets the selected words plus the relevant parts of the conversation, and the answer is short, usually a few lines.

If the first answer is not enough, press Alt+P again while the box is open and the model gets the whole conversation instead. For a very long chat, PeekMe shows the size first and sends only after one more Alt+P.

Ask is for the moments when a definition is not the question. Select a line of code, press Alt+Q, and type something like "why not use a mutex here" or "how do I fix that".

The question goes to the chat's model with the whole conversation attached, and the answer opens in the same inline box. Ask used a different key in older versions, Alt+Shift+P, before version 0.5.0 changed it to Alt+Q, so guides written before mid-October 2026 may show the old key.

The practical difference is who frames the question. Peek frames it for you when you only want to know what something means, and Ask hands you the frame when you already know what you want to find out. Both use the chat's model by default, and both answers are saved the same way.

Boxes Inside Boxes and Saved Answers

Explanations in PeekMe can nest. Select words inside an open explanation box and press Alt+P or Alt+Q again, and a new box opens inside it, under that line. The nesting goes several levels deep while the window is wide enough, so you can chase a definition inside a definition without losing your place.

Answers also stick around after the box closes. Any text you asked about gets a dotted underline, and clicking it later reopens the saved answer at once, with no new request to the model and no extra use of your plan.

A second click closes it again. In full-screen agents, clicking works directly on the underlined text.

This matters because terminal chats scroll fast. An explanation that vanished the moment you closed it would force you to ask the same question twice, and each explanation uses a little of your agent's plan or credits. Saved answers turn a one-off question into a note attached to the exact words that prompted it.

Which Coding Agents Does PeekMe Support?

PeekMe supports five terminal coding agents as of version 0.7.0. You install it once and the keys and boxes are the same in all of them, and an agent you install later picks it up automatically. The supported agents are Claude Code, Codex CLI, Pi, GitHub Copilot CLI, and Kiro CLI.

The list grew fast, from PeekMe Codex CLI only in version 0.1.0 to PeekMe Claude Code support two days later in version 0.2.0. Version 0.3.0 added GitHub Copilot CLI the day after that, version 0.5.0 added Kiro CLI on October 15, 2026, and Pi arrived with versions 0.6.0 and 0.7.0 in late October. That is five agents in 28 days, which says something about how quickly the project is moving and how quickly its agent list can go stale.

If you use Claude Code and want a fuller walkthrough of the agent itself, see how to use Claude Code. PeekMe does not replace the agent or change how it works. It only adds the explanation layer on top, and the agent's own commands, models, and billing stay exactly as they were.

How to Install PeekMe

Installing the PeekMe CLI takes two commands. First install the binary with the package manager you already use, then run peekme install once to hook it into your shell. After that, open a new terminal and start your agent as always, and PeekMe opens with it, including when you resume an existing chat.

Prebuilt binaries are published for Linux and macOS, on x86_64 and ARM, on the GitHub releases page. After the binary is in place, run peekme install and then open a fresh terminal. The command defines shell functions for each agent, so typing claude or codex starts the agent with PeekMe in front of it.

Two helper commands cover setup and removal. Run peekme doctor to check the setup when something does not work, and run peekme uninstall to remove PeekMe completely. Both are part of the tool itself, so there is no separate cleanup script to find.

npm i -g peekme
peekme install
peekme doctor
peekme uninstall

PeekMe Keybindings Cheat Sheet

PeekMe has a small set of keys, and they stay the same across all five agents. On a Mac, use Option in place of Alt, so Option+P explains and Option+Q asks. A Mac terminal types the pi symbol for Option+P, and PeekMe treats it as the shortcut only when text is selected.

One key deserves a warning. In Claude Code, Alt+P normally opens the model picker, and with PeekMe installed it explains the selection instead.

The model picker is still available through the /model command. If you press Alt+P expecting the picker, you will get an explanation box, so learn the trade early.

How PeekMe Works Under the Hood

PeekMe is a pass-through wrapper, not a fork of your agent. It starts the agent inside a pseudo-terminal, passes every byte through unchanged, and mirrors the same bytes into an in-memory terminal emulator built on the alacritty_terminal library. That mirror is how PeekMe always knows what is on your screen, down to the row and column.

Selection capture depends on how the agent draws its screen. In full-screen agents, the agent itself copies the selection with an OSC 52 escape sequence when you release the mouse, and PeekMe reads the text from that sequence as it passes through, along with where the drag ended. In classic inline screens, PeekMe reads the selection from the system clipboard or the X11 primary selection instead.

Finding the selection in the conversation is the clever part. PeekMe takes the text around the selection, marks the selection in place, and searches for that combination in the conversation it can reach.

For Codex, that conversation comes from the app-server, and since Codex 0.157 a shared server already runs in the background, so PeekMe adds only a few megabytes of memory. For Claude Code, the conversation comes from the session transcript in the projects folder, and explanations run through a background process without tools and without saving the session, so nothing appears in the resume list. For Copilot CLI, the conversation goes through its headless server, in a short session that is deleted afterwards.

The agent protocol angle is worth a note for readers who follow this space. PeekMe talks to each agent through that agent's own channels rather than a shared standard, which is why support arrives one agent at a time. For background on where agent protocols are heading, see what MCP over MOQT is.

What Does PeekMe Send? Privacy in Plain Terms

PeekMe sends the selected words and a few kilobytes of the conversation around them to the same model provider your agent already uses. There is no PeekMe server, no PeekMe account, and no API key to create. The explanation goes through the agent's own login, and each one uses a little of your agent's plan or credits.

That is a short privacy story with one honest caveat. Nothing is sent to a third-party PeekMe service, because no such service exists, but the selected text does leave your machine and go to the model provider. That is the same provider your agent already sends your prompts to, so the trust boundary does not move, yet it is not accurate to say nothing ever leaves the machine.

The temporary explanation sessions are not kept in the agent's chat history. For Claude Code, the explanation runs without saving the session, so it never shows up in the resume list.

For Copilot CLI, each explanation is a short session that is deleted afterwards. For Codex, the explanation runs on a temporary thread that is not saved. Your main chat stays clean either way.

PeekMe vs Built-In Side Questions: /btw, /side, and /ask

Each supported agent already ships its own way to ask a side question, and PeekMe does not replace those. Claude Code has /btw, Codex has /side, and Copilot CLI has /ask. The homepage itself draws the line clearly: the built-in commands are good for a question about the work, while PeekMe is for the words in front of you.

The difference is friction, not capability. A built-in side question makes you type the term you are asking about, which means copying it or spelling it from memory, and the answer lands as another message in the chat.

PeekMe skips the typing, opens the answer next to the term itself, lets the answer nest, and keeps it as a clickable underline. The two approaches work well together, and most users will reach for both in the same session.

What Are PeekMe's Limitations?

PeekMe explains only the text that is on the screen right now. Text that scrolled up into the terminal history cannot be selected yet in full-screen agents, which is the main limit to know before installing.

There is one exception: while the agent draws inline, in Kiro CLI or Claude Code's classic screen, history selection works for the last 2000 lines. The homepage still answers the scrolled-away question with "not yet", so treat the inline-history support as a partial exception, not the rule.

Windows is not supported yet. PeekMe runs on Linux and macOS, on x86_64 and ARM, in any terminal app, inside tmux, and over SSH, with Wayland supported only through XWayland.

Over SSH, install PeekMe on the remote machine where the agent runs, not on your local one. If you run agents in disposable sandboxes, see how to use E2B for a setup where a small wrapper like this fits naturally.

A few smaller limits are worth knowing. Inside tmux with Codex, turn the mouse on with set -g mouse on and restart Codex, or selection will not work.

The Alt+P key takes over Claude Code's model picker, so use /model instead. And the project is tiny, with 7 GitHub stars and 0 forks as of November 5, 2026, so there is no large community to lean on and no independent review to check the claims against. The only third-party coverage found this run was a short news blurb, and that blurb described the tool as working in a code editor, which is wrong: PeekMe works in the terminal, on the agent's own output.

PeekMe's Short History: v0.1.0 to v0.7.0 in 28 Days

PeekMe is about 40 days old as of November 5, 2026, and its first month was unusually busy. The repository was created on September 26, 2026, and the first crates.io release, version 0.1.0, was published the same day, supporting Codex CLI only on Linux with X11. Two days later came Claude Code support, one day after that came Copilot CLI, and by October 24 the project was at version 0.7.0 with five agents.

The pace is easy to count. Between September 26 and October 24, 2026, the project published 22 versions on crates.io, from 0.0.1 through 0.7.0, which averages about one release every 1.3 days across those 28 days. GitHub counts 19 releases and 170 commits in the same window, with 7 stars and 0 forks as of November 5, 2026.

One date needs care. A news site wrote on November 4, 2026 that PeekMe "officially launched" that day, but the repository and the first registry release both date to September 26, 2026.

November 4 is when the project got press coverage, not when it was born, and the article also described it as an editor tool, which it is not. The honest framing is a young project, first published in late September 2026, already at version 0.7.0 by late October, which picked up its first news write-up on November 4.

PeekMe is free and open source under MIT or Apache-2.0, and there is no price, paid tier, or subscription published anywhere. The only cost is a little of your own agent plan or credits per explanation. For a tool that is 40 days old, the fair verdict is promising and narrow: it solves one small annoyance well, it costs nothing extra, and it is still early enough that the agent list, the keybindings, and the limits can all change in the next release.

Sources

Every fact in this article comes from a page fetched on November 5, 2026. The official homepage, on peekme.dev, describes what the tool does, the five supported agents, the Alt+P and Alt+Q keys, the install routes, and the privacy model. The keys documentation, also on peekme.dev, lists the full key table, including the nested-box and scrolling behavior.

The version pages and version API (crates.io) list the release history from 0.0.1 through 0.7.0, with publish dates. The GitHub repository for the project, under Gregory Bolshakov, gives the star and fork counts, the commit count, and the license. The news article dated November 4, 2026, on emergent.sh, is cited only for the fact that it covered the project that day, since its description of how the tool works does not match the official sources.

Frequently Asked Questions

What is PeekMe?

PeekMe is a free, open-source Rust tool that explains text inside terminal coding agents. Select words in an agent's output, press Alt+P, and a short explanation opens right under the selection, inside the terminal. It works with Claude Code, Codex CLI, Pi, GitHub Copilot CLI, and Kiro CLI as of version 0.7.0.

Which terminal coding agents work with PeekMe?

Five agents work with PeekMe as of version 0.7.0: Claude Code, Codex CLI, Pi, GitHub Copilot CLI, and Kiro CLI. You install PeekMe once and the same keys work in all of them. More agents are planned, according to the project itself, but no names or dates are published.

How do I install PeekMe?

Install the binary with npm, Homebrew, Cargo, or the shell installer, then run peekme install once. Open a new terminal and start your agent as always, and PeekMe opens with it. Run peekme doctor to check the setup, and peekme uninstall to remove it.

Does PeekMe need an API key or account?

No. PeekMe has no account of its own and needs no API key. Explanations go through the agent's own login to the same model provider your agent already uses, and each one uses a little of your agent's plan or credits.

There is no PeekMe server. PeekMe itself is free and open source under MIT or Apache-2.0, and it runs on Linux and macOS, not on Windows yet.

Can PeekMe explain text that has scrolled off the screen?

Not yet in full-screen agents, where only the text on the screen now can be selected. There is one exception: while the agent draws inline, in Kiro CLI or Claude Code's classic screen, you can select text up in the terminal history for the last 2000 lines. The project says full history selection is still to come.