Connect Gemini to an LLM CLI toolchain

One-sentence takeaway

simonw/llm-gemini is a plugin that connects Google Gemini to LLM CLI; the repository's current implementation has registered the exact model gemini-3.8-flash, supports thinking_level=low|medium|high, and can enable Google Search, URL Context, and Code Execution through the repository's server-side tool mechanism. It is suitable for unifying one-off prompts, structured JSON output, and auditable tool calls in a command-line workflow.

Use cases

• Suitable tasks: Code/document analysis, batch command-line Q&A, structured information extraction, multimodal file descriptions, and controlled Agent workflows that need search or code-execution tools.

• Unsuitable tasks: Treating CLI commands as a permission system, treating tool output as a guarantee of truth, or allowing the model to perform local writes, deployments, or deletions without human confirmation.

• Applicable model version: The model registered by the repository is gemini-3.8-flash; the README's available-model list also shows the full name gemini/gemini-3.8-flash and explains that the gemini/ prefix may be omitted. The commands in this article therefore use the exact model gemini-3.8-flash.

• Applicable client, Agent, or API: The LLM CLI + llm-gemini Python plugin; the plugin accesses the model through the Gemini API. This is not a Google AI Studio, Antigravity, or native IDE Agent configuration.

• Recommended reasoning level and parameters: The repository implementation exposes three thinking_level options: low, medium, and high. Start with medium to establish a quality baseline, then switch to low / high based on latency or complexity; do not infer a long-term compatibility guarantee for the Gemini API from the repository's generic LLM option mapping.

Ready-to-use content

1. Installation and key configuration

The following commands come from the repository README. Keys should only be written to LLM's local key store or injected through environment variables; do not put them in prompts, repository files, or shell scripts.

# Install the plugin in the same Python environment as LLM CLI
llm install llm-gemini

# Interactively write to the local key store; paste the Gemini API key when prompted
llm keys set gemini

# Or use an environment variable (effective only for the current process/session)
export LLM_GEMINI_KEY='YOUR_GEMINI_API_KEY'

Check connectivity with the model list and one short request:

# gemini/gemini-3.8-flash should appear in the list
llm models -q gemini

# Exact model ID; -o uses LLM CLI's key/value option syntax
llm -m gemini-3.8-flash -o thinking_level medium \
  'In three sentences, explain what this command does and list one risk that requires human confirmation.'

If you want to set a fixed default model, the README also provides this configuration:

llm models default gemini-3.8-flash
llm 'Turn the following meeting notes into three action items, each including an owner, deadline, and information to confirm.'

2. User prompt template: analysis, constraints, and acceptance

The following user template is adapted for LLM CLI; it is not a model system prompt claimed by the repository. Pass the complete task to the CLI as a string; when files need to be referenced, add the -a attachment option.

Role: You are a rigorous technical analysis assistant.

Task: Answer the "user question" based on the "input materials."

Constraints:
1. Treat only verifiable content in the input materials as facts; write "Not provided" for missing information.
2. Do not perform local writes, deletions, deployments, or releases; when such an action is needed, first list the command and risks.
3. Mark inferences separately from facts, and identify what still requires human confirmation.

Output format:
{
  "Conclusion": "No more than 3 sentences",
  "Evidence": ["Facts directly relevant to the conclusion"],
  "Suggested actions": ["Executable steps that do not change external state"],
  "To confirm": ["Information gaps or risks"]
}

Input materials:
[Paste materials or provide attachments with -a]

User question:
[Write a question with an acceptance criterion]

Combined with the JSON output option documented in the repository README, it can be run as follows:

llm -m gemini-3.8-flash \
  -o thinking_level medium \
  -o json_object 1 \
  'Analyze the API change notes in the current directory using the template below. Return valid JSON only; fill fields without evidence with "Not provided".

Output fields: Conclusion, Evidence, Suggested actions, To confirm.'

3. Multimodal and structured workflow

The repository README shows how images, audio, video, and YouTube URLs can be attached to Gemini with -a. First perform read-only analysis of local files, then let a human decide whether to carry the conclusions into a subsequent operation:

# Review visible text/UI in an image
llm -m gemini-3.8-flash -o thinking_level low \
  'Extract the visible error messages from the image and group them as "Facts / Inferences / To confirm."' \
  -a screenshot.png

# Summarize a video timeline; media_resolution is an option publicly documented in the repository README
llm -m gemini-3.8-flash \
  -o thinking_level medium \
  -o media_resolution low \
  'Describe the key changes in the video in chronological order; do not speculate about anything outside the frame.' \
  -a recording.mp4

The workflow should be fixed as follows:

Input (text/attachments)
  -> Gemini 3.8 Flash analysis (record thinking_level explicitly)
  -> JSON/tabular output
  -> Human review of evidence and items to confirm
  -> Separate, authorized execution steps
  -> Record results and failure reasons

4. Controlled server-side tool workflow

The repository README gives the calling syntax for -T CodeExecution, -T GoogleSearch, and -T URLContext; the implementation also includes gemini-3.8-flash in the corresponding Gemini 3 capability checks. The exact-model commands below adapt the README examples to 3.8 based on the same repository implementation:

# Have the model calculate in Gemini's server-side sandbox; generated code and results still require review
llm -m gemini-3.8-flash \
  -o thinking_level medium \
  -T CodeExecution \
  'Use only Python to calculate (13 factorial) * 3, and return a summary of the calculation and the final number.'

# Enable Google Search when needed; do not treat search results directly as verified conclusions
llm -m gemini-3.8-flash \
  -o thinking_level high \
  -T GoogleSearch \
  'Search for the latest public information on the specified topic, and list source leads, dates, and facts that still require human verification item by item.'

# Use URL Context to read a URL supplied in the prompt; limit the URL scope and check for sensitive content
llm -m gemini-3.8-flash \
  -o thinking_level medium \
  -T URLContext \
  'Summarize only the paragraphs in this URL related to version changes, and return the original title and page date.'

Minimum acceptance rules for tool calls:

1. First use a no-tool request to confirm the task and output fields.
2. Enable only the one tool needed for the current task, and explicitly define the search/URL/code scope.
3. Record tool results separately from the model's conclusions; do not fill in guesses when a tool fails.
4. For external writes, deployments, payments, or deletions, stop at suggested commands and wait for human authorization.

Testing/workflow steps

1. Fix the Python environment, install llm-gemini, and use llm models -q gemini to confirm that gemini/gemini-3.8-flash is registered.

2. Run a short text smoke test with thinking_level=medium; record the exact model, input type, options, and whether the response succeeds.

3. Run a representative set of tasks with the JSON template above, checking JSON validity, evidence coverage, missing-information markers, and items to confirm.

4. Test image/audio/video attachments separately; enable CodeExecution, GoogleSearch, or URLContext only when necessary, and record tool failures.

5. Use llm logs -c --json to inspect structured logs for the current session and, if present, Gemini grounding metadata; remove keys, personal data, and internal URLs from prompts before exporting.

6. If incorporating the plugin source into a production dependency, pin an audited repository commit or release version, then repeat model registration, reasoning-level, tool, and failure-degradation tests after upgrades.

Original evidence and data

Applicability boundaries and security boundaries

• The main branch and plugin version may change; this article records the repository state viewed on 2026-09-08. Production environments should pin an audited commit/version and reconfirm that the exact model still appears in register_models.

• Some README tool examples use gemini-3.6-flash; this article applies the same syntax to 3.8 based on the capability set and model-registration code in llm_gemini.py. This is a repository-level adaptation, not an independent 3.8 compatibility statement from Google or the plugin author for every tool.

• The plugin's generic LLM options are converted into Gemini request fields; do not mistake the fact that options such as temperature, top_p, top_k, and max_output_tokens can be passed through for a guarantee about their semantics or combinations for the current model/API. Prefer setting only the explicitly exposed thinking_level that has been verified by a smoke test.

• An API key carries authorization and cost risk. Do not put the key in Markdown, Git, prompts, logs, or tickets; redact llm logs before sharing, and use least privilege and rotation for production keys.

• Although Code Execution runs in Gemini's server-side sandbox, you should still review the generated code, input data, and results; do not treat it as a local security boundary or automatically execute local commands based on its output.

• Google Search and URL Context introduce external content, time sensitivity, and potential prompt injection; restrict accessible URLs/topics, retain sources and dates, and treat external text as untrusted input.

• includeThoughts, grounding metadata, or tool events may appear in responses/logs. Do not send raw logs containing internal context, personal data, private URLs, or sensitive business information to third parties.

• Model calls, tool calls, and JSON output can all fail. On failure, command-line scripts should preserve the original input and error state, stop at a result a human can review, and not use “the model has completed” as a basis for release or writing data.

Source excerpt or observation (short excerpt for compliance only)

The repository README lists gemini/gemini-3.8-flash: Gemini 3.8 Flash; the corresponding implementation further registers it as an available model and exposes three thinking levels for it: low, medium, and high. This article uses those facts only to describe LLM CLI integration and workflows; it does not extend the repository's adapter code into a compatibility guarantee for all Gemini clients.