gptme's 5 Hidden Uses That Turn Your Terminal into an AI Powerhouse 🔥

Your terminal is now a full AI agent — and most developers are using barely 20% of its capabilities. gptme, a terminal-based AI agent with 4,313 GitHub stars, goes way beyond simple chat. It writes code, spawns subagents, navigates web pages, and even controls your desktop GUI. Yet the features that make it genuinely powerful are hiding in plain sight.

In 2026, the terminal has become the ultimate AI IDE. gptme runs entirely locally — no cloud APIs required — and ships with shell, Python, browser, vision, and computer-use tools out of the box. Here's what's buried in its docs that most developers never find.

Hidden Use #1: Parallel Task Execution with Subagent Planner Mode

What most people do: They run gptme as a single-threaded assistant — one task, one agent, waiting for completion.

The hidden trick: gptme has a subagent system that lets you spawn multiple autonomous agents working in parallel. The key is the /subagent command inside a conversation:

# In gptme chat, trigger subagent mode:
# /subagent "search the web for top AI coding tools 2026, save to research.md"
# This runs in background while you continue working on other tasks

# For complex multi-step workflows, chain subagents:
# /subagent "run data validation checks on ./data folder"
# /subagent "update API documentation based on ./src changes"
# Both run simultaneously, results merge when complete

The subagent system was introduced in v0.29.0 and supports independent planning and execution contexts. Each subagent maintains its own conversation trajectory and reports back on completion. Think of it as launching multiple AI workers from a single terminal session.

The result: You can run 3-5 agents simultaneously handling different aspects of a project — one exploring the web, one writing tests, one checking code quality — all from one terminal window.

Data sources: gptme GitHub 4,313 Stars (verified via direct API 2026-05-29); Subagent planner mode introduced v0.29.0 (2025-10), verified from GitHub releases page.

Hidden Use #2: Lessons System — Your Team's Best Practices Auto-Injected

What most people do: They treat gptme as a blank slate — every conversation starts from scratch with no context of project conventions.

The hidden trick: gptme's Lessons system auto-injects contextual guidance based on keywords, tools, and patterns detected in your conversation. Write your own lessons once, and they trigger automatically whenever relevant:

# File: ~/.config/gptme/lessons/my-project-standards.md
# Lesson format (Anthropic-compatible):

# ---
# trigger_keywords: ["api", "endpoint", "route"]
# tools: ["shell", "python"]
# ---
# When working on API endpoints in this project:
# 1. Always use FastAPI with type hints
# 2. Add Pydantic models for request/response
# 3. Include OpenAPI docstrings
# 4. Run: pytest tests/api/ --before commit

# gptme detects "api" or "endpoint" -> lesson fires automatically
# No need to manually reference conventions every time

Lessons are stored as Markdown files in ~/.config/gptme/lessons/ and matched by keyword, tool, or pattern. The system adapts to interactive vs autonomous modes, and lessons can include shell commands, code templates, and workflow steps.

The result: New team members get project-specific guidance automatically — no onboarding docs to read, no commands to memorize. The agent knows your codebase conventions from day one.

Data sources: gptme GitHub 4,313 Stars; Lessons system documented in official docs at gptme.org/docs/lessons.

Hidden Use #3: MCP Server Integration — Connect to Any MCP Tool

What most people do: They use gptme's built-in tools and don't explore the MCP ecosystem.

The hidden trick: gptme has native MCP (Model Context Protocol) support since v0.28.0. This means you can connect any MCP server as a gptme tool — filesystem, web search, databases, Slack, GitHub, anything with an MCP implementation:

# Install an MCP server, e.g. filesystem MCP
pip install mcp-server-filesystem

# Configure in gptme.toml (usually at ~/.config/gptme/gptme.toml)
[plugins]
paths = ["~/.config/gptme/plugins"]

# Or use MCP discovery for automatic tool loading
# gptme auto-discovers MCP servers configured in environment

# Then in gptme chat:
# "Read my project docs using the filesystem MCP"
# "Search the web using Tavily MCP"
# "Query my database using the Postgres MCP"

# MCP tools appear alongside native gptme tools

MCP discovery and dynamic loading was introduced in v0.29.0 with token awareness — gptme only loads relevant MCP tools based on conversation context, keeping token usage efficient.

The result: gptme becomes a unified interface for your entire MCP ecosystem — combine local filesystem MCP, Tavily web search, Postgres database, Slack notifications, and custom MCP servers all in one conversation.

Data sources: gptme GitHub 4,313 Stars; MCP support introduced v0.28.0 (2025-08) per GitHub releases; MCP discovery in v0.29.0 (2025-10) per README news section.

Hidden Use #4: Full Desktop GUI Automation with Computer Use

What most people do: They use gptme for terminal tasks — shell commands, code writing, file editing. They never think to control GUI applications.

The hidden trick: gptme has a /computer tool that gives the agent full access to your desktop. This was highlighted in v0.27 release with Claude 3.7 Sonnet integration and enables GUI automation through natural language commands:

# In gptme chat with computer tool enabled:
# "Open Chrome and search for 'gptme terminal AI agent'"
# "Click the first result, wait for page load, take a screenshot"
# "Navigate to Settings -> Privacy -> Clear browsing data"
# "Open VS Code, navigate to the last file I edited, make the same change"

# The computer tool uses Playwright under the hood for browser automation
# For native GUI apps, it uses platform-specific accessibility APIs

# Enable computer tool in gptme.toml:
[tools]
computer = true

# Computer tool handles:
# - GUI app launching and control
# - Screenshot capture (desktop, specific window, region)
# - Mouse/keyboard input simulation
# - File system navigation through GUI dialogs

The result: Automate any GUI workflow — test web applications end-to-end, configure desktop settings, extract data from GUI tools that have no CLI interface, create screen recordings with narrated agent actions.

Data sources: gptme GitHub 4,313 Stars; computer use feature referenced in v0.27 changelog (Claude 3.7 Sonnet, DeepSeek R1, local TTS with Kokoro).

Hidden Use #5: Code Intelligence with gptme-codegraph Tree-sitter MCP Tools

What most people do: They use gptme for simple code generation and editing — ask for a function, get code, done. They don't leverage its code graph capabilities.

The hidden trick: The gptme-codegraph plugin (part of gptme-contrib) provides 9 MCP tools for structural code understanding powered by Tree-sitter AST parsing:

# Install gptme-codegraph:
# pip install gptme-codegraph
# Add to gptme.toml plugins list:

[plugins]
paths = ["~/.config/gptme/plugins"]
enabled = ["gptme-codegraph"]

# Available MCP tools (9 total):
# 1. codegraph_parse    - Parse AST for a file
# 2. codegraph_call_graph - Extract function call relationships
# 3. codegraph_blast    - Find impact of changes across codebase
# 4. codegraph_symbols  - Extract all symbols (functions, classes)
# 5. codegraph_refs     - Find all references to a symbol

# Example workflow in gptme chat:
# "Parse ./src/api/routes.py and show me all function definitions"
# "Find all places that call the authenticate() function"
# "Show me the blast radius if I rename this class"
# "Extract all API endpoints and their HTTP methods"

The codegraph tools integrate via MCP, so they're available as regular gptme tools with natural language access. The blast/impact analysis is especially powerful for large refactors — ask "what breaks if I change this utility function?" and get a full impact report.

The result: Navigate complex codebases in seconds — understand call hierarchies, find symbol references, estimate change impact, extract API structure. It's like having a code analyst inside your terminal.

Data sources: gptme GitHub 4,313 Stars; gptme-codegraph from gptme-contrib repo at github.com/gptme/gptme-contrib, providing 9 MCP tools for code analysis.

Summary: 5 gptme Hidden Techniques

Subagent Planner Mode — spawn parallel AI agents for concurrent task execution
Lessons System — auto-inject project conventions and best practices via keyword triggers
MCP Server Integration — connect any MCP tool as a gptme tool (dynamic discovery + loading)
Computer Use (Full Desktop) — control GUI applications via natural language commands
gptme-codegraph MCP Tools — 9 Tree-sitter AST tools for code navigation and impact analysis

gptme turns your terminal into a multi-agent AI workstation. It is provider-agnostic, local-first, and unconstrained — one of the first agent CLIs (2023) and still in very active development.

Related Articles:

What's your most powerful gptme use case? Share below — I want to hear what you're automating.