Hoja de trucos de Gemini CLI: comandos y ejemplos

Gemini CLI se distribuye con cinco grupos de subcomandos, más de 30 banderas (flags), un REPL interactivo con más de 25 comandos, un sistema de comandos personalizados basado en archivos TOML, el framework de Skills, gestión de servidores MCP, aislamiento mediante Docker o Podman, checkpointing para rollbacks seguros, soporte para espacios de trabajo de múltiples directorios, memoria de proyecto GEMINI.md y la capacidad de migrar hooks desde Claude Code.

La documentación oficial dispersa toda esta superficie a lo largo de una docena de páginas. Esta hoja de trucos colapsa todo en una sola referencia, con salidas reales capturadas en Ubuntu 26.04 LTS usando Gemini CLI 0.40.1 contra una clave API paga de Google AI Studio.

Si vienes de la guía de instalación de Gemini CLI y quieres tener una sola página abierta mientras programas, esta es.

Verificado funcionando: Mayo de 2026 con Gemini CLI 0.40.1 contra gemini-2.5-flash-lite, gemini-2.5-pro y gemini-3-flash-preview en Ubuntu 26.04 LTS (kernel de Linux 7.0).

Recordatorio rápido de instalación

sudo npm install -g @google/gemini-cli
gemini --version

0.40.1

Para conocer todos los prerrequisitos (Node 20+, autenticación por navegador, notas sobre cuotas del nivel gratuito) y las rutas de instalación específicas para cada plataforma, el tutorial dedicado de instalación de Gemini CLI cubre Linux, macOS y Windows.

Mapa de comandos de nivel superior

Autenticación y configuración

En el primer lanzamiento, la CLI busca uno de tres métodos de autenticación. Elige el que coincida con tu cuenta:

1. Google OAuth (nivel gratuito): lanza gemini en una sesión de escritorio y sigue el flujo del navegador. ~60 solicitudes por minuto, ~1,000 solicitudes por día.
2. Clave API: establece GEMINI_API_KEY con una clave de Google AI Studio. Ideal para servidores, CI y entornos headless.
3. Vertex AI: establece GOOGLE_GENAI_USE_VERTEXAI=true con una cuenta de servicio. Ideal para empresas o equipos con facturación en GCP.

Error real de una máquina nueva sin claves:

$ gemini -p 'echo /help' --output-format text
Por favor, establece un método de autenticación en tu /root/.gemini/settings.json
o especifica una de las siguientes variables de entorno antes de ejecutar:
  GEMINI_API_KEY, GOOGLE_GENAI_USE_VERTEXAI, GOOGLE_GENAI_USE_GCA

Y un error real de cuota del nivel gratuito cuando se alcanza el límite diario:

* Cuota excedida para la métrica: generativelanguage.googleapis.com/generate_content_free_tier_requests,
  límite: 5, modelo: gemini-3-flash
Por favor, reintenta en 718.667265ms.
Reintento sugerido después de 60s.

Ejecuta /stats dentro del REPL para ver el uso de tokens en tiempo real, o observa la salida JSON de --output-format json en modo headless (imprime un objeto de estadísticas completo después de cada llamada).

Clave API en un servidor Linux

export GEMINI_API_KEY="aiza..."
echo 'export GEMINI_API_KEY="aiza..."' >> ~/.bashrc
gemini --list-extensions

Dónde la CLI almacena el estado

Diseño real de una instalación funcional después de algunas sesiones:

$ ls -la ~/.gemini/
drwxr-xr-x  history/                 # Transcripciones del REPL interactivo por proyecto
-rw-r--r--  installation_id          # ID de telemetría anonimizada
-rw-r--r--  projects.json            # Mapa de proyectos conocidos
drwxr-xr-x  tmp/                     # Scratch del sandbox de herramientas
drwxr-xr-x  commands/                # Comandos slash personalizados en TOML
# settings.json aparece una vez que guardas preferencias vía /settings o a mano

El archivo projects.json rastrea en qué directorios has usado la CLI:

$ cat ~/.gemini/projects.json
{
  "projects": {
    "/root":           "root",
    "/root/gem-demo":  "gem-demo"
  }
}

Jerarquía y esquema completo de settings.json

La configuración se carga en este orden de prioridad. El principio de la lista gana:

1. Proyecto: ./.gemini/settings.json
2. Usuario: ~/.gemini/settings.json
3. Sistema: /etc/gemini-cli/settings.json (solo se usa si está presente, útil para instalaciones gestionadas)

Referencia anotada que cubre las claves que la mayoría de los usuarios realmente tocan:

{
  "selectedAuthType": "USE_GEMINI",        // OAuth | USE_GEMINI | VERTEX
  "theme": "Default Dark",
  "vimMode": false,                        // Atajos de teclado de vim en la entrada
  "preferredEditor": "vim",                // Para /editor y Ctrl+X
  "autoAccept": false,                     // Auto-confirmar llamadas a herramientas de solo lectura
  "checkpointing": { "enabled": true },    // Habilita /restore
  "sandbox": "docker",                     // docker | podman | false
  "usageStatisticsEnabled": false,         // Telemetría anónima
  "includeDirectories": [
    "../backend",
    "../frontend"
  ],
  "fileFiltering": {
    "respectGitIgnore":     true,
    "respectGeminiIgnore":  true
  },
  "chatCompression": {
    "contextPercentageThreshold": 60       // Activar /compress al 60%
  },
  "customThemes": {
    "my-theme": { /* tokens de color */ }
  },
  "excludeTools": ["run_shell_command"],   // Lista negra de herramientas por completo
  "coreTools": ["read_file", "write_file"],// Lista blanca de herramientas principales (otras desactivadas)
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"],
      "timeout": 15000,
      "trust": false,
      "includeTools": ["search_docs"],
      "excludeTools": ["delete_doc"]
    }
  },
  "telemetry": { "enabled": false }
}

Las anulaciones a nivel de proyecto viven en ./.gemini/settings.json en la raíz del repositorio. Se aplica el mismo esquema; los valores del proyecto anulan los valores del usuario.

.geminiignore

Coloca un archivo .geminiignore en la raíz del repositorio para mantener al agente alejado de archivos generados, secretos y directorios grandes. Misma sintaxis que .gitignore:

# .geminiignore
node_modules/
dist/
.next/
.env
.env.*
*.log
secrets/
infra/state/

Memoria de proyecto GEMINI.md

Un archivo GEMINI.md en la raíz del proyecto se carga automáticamente en el contexto en cada sesión. El patrón es similar a CLAUDE.md en el directorio .claude. La memoria se carga jerárquicamente: global (~/.gemini/GEMINI.md), luego el proyecto, y luego cualquier GEMINI.md por subdirectorio para la ruta en la que estás trabajando.

Las importaciones funcionan mediante la sintaxis @./path dentro de cualquier GEMINI.md:

# GEMINI.md
@./docs/architecture.md
@./docs/coding-style.md

## Contexto del proyecto
Este es un microservicio en Go que...

## Compilación y pruebas
- Compilar: `make build`
- Probar:  `go test ./...`
- Lint:    `golangci-lint run`

Genera un archivo inicial con /init desde dentro del REPL. Recarga después de editar con /memory refresh.

Referencia de banderas globales

Alias de modelos

Modo headless para scripts

# Revisión rápida de código de un diff
git diff main | gemini -p "Review this diff for security issues. Format: bullets."

# Salida JSON para análisis posterior (incluye estadísticas completas de tokens)
gemini -p "List the top 3 risks in this Dockerfile" --output-format json < Dockerfile

# Transmitir eventos JSON para captura de logs amigable con tail
gemini -p "Summarise this log" --output-format stream-json < /var/log/syslog

# Contexto de múltiples directorios vía --include-directories
gemini -p "Find shared validation logic" --include-directories /repo/backend,/repo/frontend

Pegatina de confianza en servidores: Gemini se niega a ejecutarse dentro de un directorio no confiable a menos que optes por ello. Error real de un clonación nueva:

Gemini CLI is not running in a trusted directory.
To proceed, either use --skip-trust, set GEMINI_CLI_TRUST_WORKSPACE=true,
or trust this directory in interactive mode.

Pasa --skip-trust para llamadas de un solo uso, o establece GEMINI_CLI_TRUST_WORKSPACE=true en el entorno para un ejecutor de CI.

Captura de sesión real (salida JSON)

Salida auténtica de una ejecución real, capturada exactamente como la emitió la CLI. Nota la división de doble modelo (un modelo enrutador clasifica, el modelo principal responde) y el desglose de tokens por modelo:

$ gemini --skip-trust -p 'In one sentence, what does this code do?' \
    --output-format json --include-directories /root/gem-demo

{
  "session_id": "5bd072ad-8d9b-4d86-89d2-1b1371a3e612",
  "response": "The code defines a function that implements the FizzBuzz algorithm...",
  "stats": {
    "models": {
      "gemini-2.5-flash-lite": {
        "api":    { "totalRequests": 1, "totalLatencyMs": 3405 },
        "tokens": { "input": 742, "candidates": 55, "thoughts": 346, "total": 1143 },
        "roles":  { "utility_router": { "totalRequests": 1, "..." } }
      },
      "gemini-3-flash-preview": {
        "api":    { "totalRequests": 2, "totalLatencyMs": 4131 },
        "tokens": { "input": 15734, "..." }
      }
    }
  }
}

Redirige la transmisión a jq para filtrar las partes que necesitas:

# Solo la respuesta
gemini -p "summarise" --output-format json | jq -r .response

# Tokens totales gastados en todos los modelos
gemini -p "review repo" --output-format json | jq '[.stats.models[].tokens.total] | add'

Comandos slash del REPL interactivo

Archivos @ y paso a shell !

Dos patrones hacen que el REPL sea diez veces más rápido:

# Adjuntar un archivo
@src/auth.ts review this for SQL injection

# Adjuntar múltiples archivos
@src/auth.ts @src/db.ts find shared validation logic

# Adjuntar un directorio entero recursivamente (respeta .gitignore + .geminiignore)
@./src/api/

# Adjuntar una imagen para modelos con capacidad de visión
@screenshot.png explain what this UI is doing

# Ejecutar un comando de shell y devolver la salida al chat
!git status
!docker compose ps

# Entrar en modo shell persistente (un solo ! en su propia línea)
!
$ pwd
$ ls -la
$ !          # sale del modo shell

Comandos slash personalizados (TOML)

Los comandos personalizados son archivos TOML colocados en .gemini/commands/ (proyecto) o ~/.gemini/commands/ (usuario). El nombre del archivo se convierte en el comando slash. Una carpeta de categoría produce comandos con espacio de nombres:

• ~/.gemini/commands/review.toml → /review
• ~/.gemini/commands/security/audit.toml → /security:audit

Esquema TOML

# ~/.gemini/commands/review.toml
description = "Review code for security issues"
prompt = """Please review the following code for security vulnerabilities:

{{args}}

Focus on injection, auth, and crypto issues."""

Invócalo desde el REPL o modo headless. El marcador de posición {{args}} recibe lo que escribas después del nombre del comando. El agente tiene acceso a cualquier archivo @ que menciones:

$ gemini -p '/review @unsafe.py'
1. Avoid `os.system`. Use the `subprocess` module instead, which provides
   better control and security.
2. Use Argument Lists. When using `subprocess.run` or `subprocess.Popen`,
   pass the command and its arguments as a list rather than a single string.
3. Disable Shell Execution. Set `shell=False` to ensure the command is
   executed directly without a shell.
...

Referencia de herramientas integradas

El agente llama a estas herramientas directamente. Listalas en tiempo de ejecución con /tools y bloquea individuos mediante excludeTools o coreTools en settings.json.

Sandbox: Docker o Podman

La bandera --sandbox y "sandbox": "docker" | "podman" en settings le dicen a la CLI que ejecute cada llamada de herramienta de shell dentro de un contenedor. El agente aún puede leer y escribir archivos en el espacio de trabajo, pero la ejecución de binarios ocurre en un entorno aislado. Útil cuando no confías en una extensión o quieres probar comandos arriesgados sin dejar rastros.

# Ejecución de sandbox de un solo uso
gemini --sandbox -p "build and run the test suite"

# Sandbox permanente vía settings
echo '{"sandbox":"docker"}' > ~/.gemini/settings.json

Combina el sandbox con --approval-mode plan para el modo más estricto de “mirar, no tocar”.

Checkpointing y /restore

El checkpointing toma instantáneas de los archivos antes de cada edición del agente. Si una refactorización sale mal, revierte sin tocar git:

# Habilitar para una sesión
gemini --checkpointing

# O persistir en settings.json
{
  "checkpointing": { "enabled": true }
}

Dentro del REPL:

/restore           # listar puntos de control
/restore 3         # revertir al punto de control 3 (archivos + estado del chat)

Usa esto cuando iteres sobre una refactorización complicada: pregunta, revisa, restaura, reintenta. Más rápido que git stash para pequeños experimentos.

Modos de aprobación

Atajos de teclado

Gestión de servidores MCP

$ gemini mcp add --help
Usage: gemini mcp add [options] <name> <commandOrUrl> [args...]
Options:
  -s, --scope          user | project (default: project)
  -t, --transport      stdio | sse | http (default: stdio)
  -e, --env KEY=value  environment variables (repeatable)
  -H, --header         HTTP headers for sse/http (repeatable)
      --timeout        connection timeout in ms
      --trust          bypass tool-call confirmation prompts
      --description    server description
      --include-tools  comma-separated tool whitelist
      --exclude-tools  comma-separated tool blacklist

Adiciones comunes de servidores

# Filesystem (alcance a un directorio)
gemini mcp add filesystem npx -y @modelcontextprotocol/server-filesystem /home/user/projects

# GitHub (necesita GITHUB_TOKEN)
gemini mcp add github -e GITHUB_TOKEN=$GITHUB_TOKEN \
  npx -y @modelcontextprotocol/server-github

# Postgres
gemini mcp add postgres npx -y @modelcontextprotocol/server-postgres \
  "postgresql://user:pass@host:5432/db"

# Context7 con lista blanca de herramientas
gemini mcp add context7 --include-tools search_docs \
  npx -y @upstash/context7-mcp@latest

# Servidor SSE remoto con encabezado de autenticación
gemini mcp add company-tools https://mcp.company.com/sse \
  --transport sse \
  -H "Authorization: Bearer $MCP_TOKEN" \
  --timeout 20000

Lista el conjunto activo con gemini mcp list, alterna individuos desde dentro del TUI con /mcp, reinicia todos ellos con /mcp reload.

Skills

Los Skills son roles de agente autocontenidos con su propio prompt, herramientas y metadatos. La CLI incluye un skill integrado (skill-creator) que te ayuda a escribir otros nuevos. Salida de lista real:

$ gemini skills list --all
Discovered Agent Skills:

skill-creator [Enabled] [Built-in]
  Description: Guide for creating effective skills.
  Location:    /usr/local/lib/node_modules/@google/gemini-cli/bundle/builtin/skill-creator/SKILL.md

# Instalar desde un repositorio git (alcance de usuario por defecto)
gemini skills install https://github.com/your-org/skill-release-notes

# Instalar desde una sub-ruta dentro de un monorepo de skills
gemini skills install https://github.com/some/monorepo --path skills/security-review

# Instalación con alcance de proyecto
gemini skills install ./local-skill --scope workspace

# Enlazar en vivo un skill local mientras lo construyes
gemini skills link ./security-review

# Alternar individuos (o todos)
gemini skills enable security-review
gemini skills disable security-review
gemini skills enable --all
gemini skills disable --all

# Reconocer riesgos de seguridad y omitir el aviso
gemini skills install <source> --consent

Extensiones

Las extensiones agrupan comandos, temas, servidores MCP, manejadores de hooks y políticas. Distribuye un kit de herramientas completo a un equipo en una sola URL de git.

# Instalar desde un repositorio de github con auto-actualización
gemini extensions install https://github.com/your-org/your-extension --auto-update

# Instalar en una referencia git específica (etiqueta, rama, commit)
gemini extensions install https://github.com/your-org/your-extension --ref v2.1.0

# Instalar compilaciones pre-release
gemini extensions install https://github.com/your-org/your-extension --pre-release

# Instalar desde una copia local (enlazado en vivo, las ediciones se reflejan inmediatamente)
gemini extensions link ./my-extension

# Listar instaladas
gemini extensions list

# Actualizar todo
gemini extensions update --all

# Deshabilitar temporalmente
gemini extensions disable my-extension

# Validar antes de publicar
gemini extensions validate ./my-extension

# Andamiar una nueva extensión desde una plantilla
gemini extensions new ./my-new-ext mcp-server

Plantillas disponibles para extensions new: custom-commands, exclude-tools, hooks, mcp-server, policies, skills, themes-example.

Hooks (migrar desde Claude Code)

Si ya escribiste hooks para Claude Code, el comando migrate los reescribe en el formato de Gemini:

$ gemini hooks migrate --from-claude
# Reads .claude/settings.json, writes converted hook config under .gemini/
# Prints any hooks that need manual review

El sistema de hooks en sí usa la misma taxonomía de eventos: PreToolUse, PostToolUse, Stop, UserPromptSubmit. La reescritura preserva los selectores (matchers) y comandos, pero cualquier cosa que llamara a un nombre de herramienta específico de Claude necesita una actualización manual.

Enrutamiento local de modelos Gemma

Gemma es la familia de modelos de pesos abiertos de Google. El subcomando gemini gemma aprovisiona un servidor local LiteRT-LM para que la CLI pueda enrutar prompts a un modelo Gemma alojado en CPU o GPU en lugar de la API en la nube. Útil para trabajo sin conexión, código sensible o para ahorrar cuota del nivel gratuito:

# Descargar modelo + tiempo de ejecución, puerto por defecto 9379
gemini gemma setup

# Configurar sin iniciar automáticamente
gemini gemma setup --start=false

# Volver a descargar incluso si está presente
gemini gemma setup --force

# Ciclo de vida
gemini gemma start
gemini gemma status
gemini gemma logs
gemini gemma stop

Con Gemma ejecutándose, establece el modelo por cada invocación con -m gemma-3-12b. Combínalo con --approval-mode plan para exploración local de solo lectura que no cuesta nada y no filtra nada.

Sesiones, historial y reanudación

gemini --list-sessions             # qué es recuperable
gemini --resume latest             # retomar la más reciente
gemini --resume 3                  # retomar índice 3
gemini --delete-session 5          # limpiar

Salida real después de una ejecución:

$ gemini --list-sessions
Available sessions for this project (1):
  1. List 3 functions defined (Just now) [875c2ac1-4eec-42dd-a7b0-cccc97bcbd53]

Las sesiones viven bajo ~/.gemini/history/<project>/. Son JSON, por lo que puedes usar grep, archivarlas o introducirlas en otra herramienta.

Flujo de trabajo con Worktree

La bandera -w inicia el agente dentro de un git worktree nuevo. Útil para sesiones paralelas en el mismo repositorio, o para mantener las ediciones del agente aisladas de tu rama en curso.

# Worktree con nombre automático
gemini -w -p "refactor src/auth/* into smaller modules"

# Worktree nombrado (creado si falta, reutilizado si existe)
gemini -w fix-flaky-tests

Cuando el agente termina, revisa el diff con git diff dentro del worktree, luego fusiona o descarta con los comandos usuales de git worktree.

Integración con IDE

La CLI puede adjuntarse a un editor para un contexto más rico (posición del cursor, archivo abierto, vista de diff). Actualmente mejor soportado en VS Code y Zed:

# Dentro del REPL
/ide install     # instala la extensión compañera
/ide enable      # conecta esta sesión al IDE

# O para Zed (ACP / Agent Client Protocol)
gemini --experimental-acp
gemini --experimental-zed-integration

Formatos de salida y análisis JSON

# Texto plano. Predeterminado. Mejor para tuberías de shell y humanos.
gemini -p "summarise" --output-format text < report.md

# JSON. Un objeto en stdout. Más fácil de analizar con jq.
gemini -p "extract action items" --output-format json < meeting.txt | jq .

# Stream JSON. Un evento por línea. Mejor para prompts de larga duración.
gemini -p "review the entire repo" --output-format stream-json | tee events.ndjson

Usa --raw-output solo cuando necesites específicamente preservar los escapes ANSI. Combínalo con --accept-raw-output-risk para suprimir la advertencia de seguridad. La salida de un modelo no confiable redirigida a una terminal puede emitir secuencias de control, así que deja la advertencia activada siempre que las fuentes del prompt no sean tuyas.

Errores comunes y soluciones

Error: “Please set an Auth method”
No hay variable de entorno, ni settings.json. Exporta GEMINI_API_KEY o ejecuta gemini interactivamente una vez y elige un método de autenticación.

Error: “Gemini CLI is not running in a trusted directory”
Pasa --skip-trust para una ejecución, establece GEMINI_CLI_TRUST_WORKSPACE=true en el entorno para CI, o confía en el directorio una vez desde la UI interactiva para trabajo normal de escritorio.

Error: “Quota exceeded for metric: generate_content_free_tier_requests”
El OAuth del nivel gratuito tiene límites por minuto y por día. La CLI reintenta automáticamente con retroceso, pero si se alcanza el límite diario debes esperar hasta que se reinicie. Cambia a autenticación por clave API (clave paga de AI Studio) o a un modelo local Gemma por el resto del día.

Error: “Ripgrep is not available. Falling back to GrepTool”
Instala ripgrep (sudo apt install -y ripgrep en Ubuntu, sudo dnf install -y ripgrep en Rocky/Fedora). Gran mejora de velocidad en repositorios grandes. La CLI retrocede elegantemente si falta, pero las búsquedas tardan más.

Problema: Discrepancias de rutas en WSL2
Si gemini se lanza bajo Windows pero intenta leer una ruta de WSL, configura PATH y HOME de manera consistente. La solución más fácil: instala Gemini CLI dentro de la distribución de WSL usando las instrucciones de Linux, no el instalador de Windows.

Gemini CLI vs Claude Code vs Codex CLI vs Aider vs OpenCode

Elegir entre los agentes de codificación con IA de terminal depende del presupuesto, el ecosistema y el comportamiento del modelo que prefieras:

• Gemini CLI: Nivel gratuito de OAuth (60 RPM, 1K RPD), contexto de 1M de tokens para Gemini 2.5 Pro, herramienta de Google Search nativa, fuerte en razonamiento de documentos largos.
• Claude Code: Pro/Max de pago, ecosistema de agentes más profundo (skills, hooks, MCP), mejores modelos Sonnet/Opus. Ver la hoja de trucos de Claude Code.
• Codex CLI: OpenAI de pago por uso, el más afilado para refactorizaciones cortas y enfocadas. Ver la hoja de trucos de Codex CLI.
• Aider: Nativo de git, multi-proveedor, consciente del mapa del repositorio. Ver la hoja de trucos de Aider.
• OpenCode: TUI de código abierto, modo servidor nativo, multi-proveedor. Ver la hoja de trucos de OpenCode CLI, más la comparación OpenCode vs Claude Code vs Cursor.

Preguntas frecuentes

¿Es gratis Gemini CLI?

Sí, en el nivel de OAuth. Inicia sesión con una cuenta de Google y obtienes ~60 solicitudes por minuto y ~1,000 solicitudes por día sin costo. El uso más pesado se enruta a través de una clave API de AI Studio, que se paga por token.

¿Dónde está el archivo de configuración de Gemini CLI?

La configuración a nivel de usuario es ~/.gemini/settings.json. Las anulaciones a nivel de proyecto van en ./.gemini/settings.json. La configuración de todo el sistema puede vivir en /etc/gemini-cli/settings.json. Los valores del proyecto anulan los valores de usuario, que anulan los valores del sistema. Los comandos personalizados viven junto a ellos en commands/.

¿Cómo creo un comando slash personalizado en Gemini CLI?

Coloca un archivo TOML en ~/.gemini/commands/<name>.toml (usuario) o .gemini/commands/<name>.toml (proyecto). Establece description y prompt; usa {{args}} como marcador de posición. Un subdirectorio se convierte en una categoría, por lo que commands/security/audit.toml crea /security:audit.

¿Puede Gemini CLI ejecutarse sin conexión?

Sí. Ejecuta gemini gemma setup para descargar un modelo Gemma y el tiempo de ejecución LiteRT-LM localmente. Una vez que el servidor local se esté ejecutando en el puerto 9379, establece -m gemma-3-12b (o la variante que hayas descargado) y la API en la nube ya no será necesaria.

¿Cómo uso servidores MCP con Gemini CLI?

Añade un servidor con gemini mcp add <name> <command> [args]. Pasa -t http o -t sse para servidores remotos. Usa -e KEY=val para variables de entorno, -H "Header: value" para encabezados HTTP, y --include-tools / --exclude-tools para incluir o excluir herramientas expuestas. Lista los servidores activos con gemini mcp list o /mcp desde dentro del TUI.

¿Cuál es la diferencia entre auto, pro, flash y flash-lite?

auto es el enrutamiento predeterminado de Gemini (típicamente Gemini 2.5 Pro, o 3-Pro-preview si las vistas previas están habilitadas). pro fija la misma familia para razonamiento complejo. flash usa Gemini 2.5 Flash para trabajo diario rápido. flash-lite usa la variante más barata y rápida para tareas de utilidad como enrutamiento o resúmenes cortos.

¿Cómo revierto los cambios que hizo el agente?

Lanza con --checkpointing (o establece "checkpointing": {"enabled": true} en settings.json). Dentro del REPL, ejecuta /restore para listar instantáneas y /restore <id> para revertir archivos y estado de conversación a ese punto.

Mantén esto abierto mientras trabajas

Gemini CLI avanza rápido. Cuando llegue una nueva versión, revisa el bloque de actualidad en la parte superior de esta página para confirmar que la versión que estás ejecutando coincide con la que se probó.

Combina esto con la guía de instalación de Gemini CLI para la configuración inicial, la hoja de trucos de Aider si alternas con ese agente y la hoja de trucos de comandos de Ollama, Si también ejecutas modelos locales en paralelo.