Gemini CLI v0.9: Interactive Genkit Agent Beats Claude Code

Introduction

The latest Gemini CLI update is a significant step forward for building and iterating on AI applications directly from the terminal. After the Genkit integration brought deep awareness of Genkit’s architecture, patterns, and tools, version 0.9 adds a new level of interactivity that makes daily development smoother and more cohesive.

With v0.9, interactive terminal applications now run inside Gemini CLI itself. Editors, monitors, and operations that previously broke the flow can stay within one context. In practice, this makes Gemini CLI feel more familiar and far more capable for real development tasks.

I find this update makes Gemini CLI a stronger option than many coding agents. It’s free, and the interactivity unlocks practical workflows that developers depend on every day.

What Is the Gemini CLI?

This article covers Gemini CLI v0.9, with a focus on its new interactive terminal capabilities, how those capabilities work under the hood, and what else ships in this release. It also highlights the extensions ecosystem available through Genkit, plus what to expect next on the roadmap.

Overview of the Update

Area	What Changed	Why It Matters
Interactivity	Interactive terminal apps now run inside Gemini CLI	Keep work in one place with full context maintained
PTY Support	Pseudo terminal (PTY) support via node-pty	Commands behave like they do in a native terminal
Rendering	Real-time terminal serialization and streaming	Live, responsive interface for rich terminal output
Two-way IO	Direct typing, editing, resizing, and app interaction	True bidirectional control inside the CLI
Focus and Output	Control+F to focus terminal; full-color rendering	Faster navigation; better readability
Extensions	New extensions available through Genkit	Broader capabilities inside Gemini CLI
Observability	OpenTelemetry metrics added	Standardized metrics for interoperability
Memory Tools	/memory list command	Quick access to long-term memory files
Developer UX	Easier extension creation; UI polish and fixes	Faster setup and smoother day-to-day use
Availability	Pre-release build of v0.9	Try new features before the stable 1.0 release

Key Features of Gemini CLI v0.9

Full interactivity inside Gemini CLI with editors, system monitors, and version control operations
Pseudo terminal support so commands behave as if running in a native terminal
Real-time rendering with serialized terminal state for responsive output
Two-way interaction: typing, editing, and resizing work as expected
Focus shortcut (Control+F) and color output for readable, engaging terminal sessions
New metrics via OpenTelemetry for better observability
Easier extension creation, memory file listing, and general polish
Expanded extensions through Genkit, including tools for design, documentation, and more

Why Interactivity Matters

Previously, running interactive shell commands required exiting Gemini CLI. That broke context: the CLI wasn’t aware of actions performed outside, so your agent didn’t have the full picture of what changed or why.

Version 0.9 addresses this by keeping the entire workflow inside Gemini CLI. You can open interactive tools, perform edits, monitor processes, and commit changes without leaving the CLI session. The agent stays aware of everything, preserving state and intent for more accurate guidance and follow-up steps.

This update makes working in Gemini CLI feel cohesive. Instead of hopping across terminals or dealing with frozen sessions, you can stay in one place, keep context, and move faster.

How the New Interactivity Works

Pseudo Terminal Support (PTY)

Under the hood, Gemini CLI spawns shell commands inside a pseudo terminal using the node-pty library. The PTY acts as a bridge that presents the operating system with the interface of a real terminal session.

This approach ensures commands behave the same way they do in a native terminal. From keystrokes to control codes, the process receives exactly what it expects, so interactive tools run correctly and remain responsive.

Real-time Terminal Serialization

To display this virtual terminal, Gemini CLI uses a serializer that captures the PTY state in real time. It snapshots characters, colors, cursor positions, and more, then streams those snapshots back to the interface.

The result is a live, interactive feed rather than static output. You see what the process sees—immediately and accurately—so you can respond, edit, and navigate without delay.

True Two-way Interaction

The architecture supports full bidirectional communication:

Inputs you type are transmitted to the running process
The application’s output is rendered live with proper formatting and color
Resizing the window signals the process, which adapts instantly
Editing and navigation work as they would in a native terminal

Gemini CLI also offers a Control+F focus command to jump directly into the terminal. This is helpful when switching between the conversational panel and the terminal pane during complex workflows.

Working Inside Gemini CLI v0.9

Staying in Context

Because everything runs within the same session, Gemini retains awareness of your actions. Command results, file edits, and status updates all flow into the same context, making the agent more reliable when summarizing, suggesting next steps, or troubleshooting.

This consistent context is especially useful during iterative work. You can make a change, test it with an interactive tool, and then ask the agent to fix issues or expand the solution—all without losing continuity.

Interactive Workflows

With PTY support and real-time rendering, you can carry out interactive development tasks entirely inside Gemini CLI. Editing, monitoring, and complex version control operations behave correctly and remain responsive.

The terminal now renders color output, improving readability for logs, diffs, and status information. Combined with the focus command, navigation becomes quick and predictable.

Additional Updates in v0.9

Pre-release Availability

The v0.9 features are available through a pre-release build. You can install it from your terminal and start experimenting before the stable 1.0 release arrives.

If you’re evaluating Gemini CLI for everyday use, the pre-release is the best way to test the new interactivity and observe the benefits of keeping everything in one session.

Easier Extension Creation

Creating extensions is simpler. You can generate a blank extension without templates, making it faster to start and customize integrations for your team’s needs.

This helps you shape Gemini CLI to your workflows—adding commands, tools, or integrations that align with how your projects are structured.

OpenTelemetry Metrics

The release includes standardized metrics through OpenTelemetry. This supports better interoperability with observability tools and helps teams monitor performance and behavior.

Metrics are an important step toward managing agent-driven development at scale. They create visibility into usage patterns and outcomes that matter for teams.

Memory File Listing

You can now list long-term memory files with the /memory list command. This makes it easier to locate stored memory and understand what the agent can recall during a session.

If you keep reference data or decisions in memory, quick listing helps you verify what’s available and ensure the agent is grounding its suggestions on current information.

General Polishes and Fixes

The update includes UI improvements and bug fixes. These refinements support a smoother day-to-day experience and help ensure interactive commands behave consistently across sessions.

Extensions Through Genkit

Gemini CLI now features a broader set of extensions accessible via Genkit. You can add tools that expand the CLI’s capabilities and bring common tasks into one place.

Design and content tools can run inside the terminal for browsing, previewing, and downloading assets
Documentation tools can fetch up-to-date code docs for your agents
Additional MCPS integrations and others extend workflows across development and operations

Installation is straightforward: copy the extension command and run it in your terminal. From there, the extension becomes part of your working environment inside Gemini CLI.

Step-by-step: Getting Started With v0.9 Interactivity

Follow these steps to adopt the new interactive experience:

Install the pre-release build of Gemini CLI v0.9 from your terminal.
Open Gemini CLI and confirm the v0.9 features are available.
Start an interactive development session and keep your work within the CLI to preserve context.
Use Control+F to focus the terminal when you need to type or navigate.
Resize the window as needed; the running process adapts instantly.
Add extensions through Genkit to bring additional tools into the CLI.

Step-by-step: Using Memory and Metrics

List long-term memory files with the /memory list command to see what’s stored.
Review OpenTelemetry metrics in your observability stack to understand usage and performance.
Adjust your workflows based on insights from metrics and memory, keeping more work inside the Gemini session.

Practical Notes on Developer Experience

Consistent context: Keeping everything in one session means the agent understands your workflow end-to-end. This reduces confusion and improves the quality of suggestions and fixes.
Familiar terminal behavior: PTY support ensures commands behave as expected, so there’s no learning curve for interactive apps you already know.
Cohesive setup: With extensions, telemetry, and memory tools in one place, you can standardize how your team builds and iterates on AI features.

For teams that previously relied on paid terminals or external tools for interactivity, Gemini CLI v0.9 provides similar benefits at no cost, integrated with the agent experience you already use.

Technical Deep Dive

PTY Process Model

Gemini CLI spawns interactive processes inside a pseudo terminal created via node-pty
The PTY exposes a real terminal interface to the operating system and the running process
This guarantees that keystrokes, control codes, and terminal states are interpreted correctly

The process model is robust and mirrors a native terminal, which is why applications treat the session as authentic and respond as they should.

Serializer and Streaming

A Gemini serializer captures the full terminal state: characters, colors, cursor position, and more
It snapshots this state in real time and streams it to the Gemini interface
You see an accurate, live representation of the terminal as if you were in a dedicated terminal emulator

This approach avoids the pitfalls of static output and makes interactive tools viable within an agent-driven environment.

Bidirectional IO and Resizing

Input flows directly from your keyboard to the process
Output is immediately rendered with correct formatting
Window size changes are communicated to the process, which adapts without manual intervention

Together, these features create a responsive feeling that supports complex workflows without breaking the CLI session.

Extension Highlights

Extensions enhance Gemini CLI with extra capabilities:

Design extensions support browsing, previewing, and downloading assets inside the terminal
Documentation extensions provide current code references for your agents
MCPS and related extensions add specialized workflows for engineering and operations

By combining extensions with the new interactivity, you can bring more of your daily tasks into a single, context-aware environment.

Roadmap and Timeline

The v1.0 release is approaching and expected within weeks. The team is also aligning with the Gemini 3.0 release, which is currently anticipated in December. Timelines can shift, but the trajectory points to a strong cycle of improvements leading into the stable release.

Frequently Asked Questions

Does v0.9 change how I run commands?

Interactive commands now run inside Gemini CLI with full context. You can type, edit, and navigate as you would in a native terminal, and the agent remains aware of your actions.

How do I focus the terminal pane?

Use Control+F to focus the terminal, then type as usual. Switch back to the conversation pane when you need agent input or summaries.

What’s the benefit of OpenTelemetry metrics?

They provide standardized metrics you can connect to your observability stack. This helps you monitor usage, performance, and outcomes as you adopt agent-driven workflows.

How do I find stored memory?

Run the /memory list command to see long-term memory files and understand what the agent can recall in your session.

Summary

Gemini CLI v0.9 brings full interactivity into the agent experience. With PTY support, real-time rendering, two-way IO, and session-aware context, you can perform complex terminal work without leaving the CLI. The release also improves extension development, adds OpenTelemetry metrics, introduces memory listing, and ships UI polish and fixes.

If you’ve been waiting for a single, context-rich place to run interactive development tasks, this update makes Gemini CLI a compelling daily driver. With 1.0 on the way and a broader Gemini 3.0 release expected in December, the tool is maturing quickly and aligning with the needs of real-world development.