Gener - Micro Prompting AI Coding Agent dedicated for VS Code

Build on Cline's Foundation, Evolve Beyond.

⚡ Witness Gener in Action — Works with Gemini Flash & 100% Free!

Gener is an autonomous coding agent embedded directly in VS Code — a name born from four core principles:

🚀 Why Gener?

Gener is engineered to excel across every layer of the agentic coding experience:

✨ Key Features

🔍 Exclusive Semantic Codebase Index & Dependency Graph

Gener builds a persistent, incremental dependency graph and semantic codebase index under the hood. This enables:

• Symbol-aware dependency graph queries — Find where symbols are defined, imported, and used across your entire codebase works simiar to VSCode's "Find All References/Implemetations" but for AI models
• Local semantic search — Natural language search powered by tiny on-device embedding models (minilm, jina-small, nomic, jina-code) downloaded on-the-fly from Hugging Face — no API calls, no token cost
• Private by design — Your codebase stays 100% local; nothing is sent to any external service, so ownership and privacy are fully yours
• Zero token cost — Because embeddings run locally, semantic search costs you nothing per query
• Regex & dependency graph search modes — Flexible search strategies for different use cases
• Real-time indexing — Background worker with throttled file processing for large repos
• SQLite-backed storage — Fast, local-first indexing that persists across sessions

// Example: Search for symbol usages across the codebase
searchFiles(
  path: "src",
  searchTerm: "getUserInfo",
  mode: "dependencyGraph"  // 🔗 Dependency graph mode
)

// Example: Semantic search by meaning, not just text
searchFiles(
  path: "src",
  searchTerm: "how this app authenticate users",
  mode: "bm25"  // 🧠 AI-powered semantic search
)

🧠 Cross-Session Memory

Gener auto-discovers, creates and manages cross-session memory so it remembers context across conversations:

• Auto-injects the most recent 50 memories into the system prompt with LLM-tagged keywords and a short summary
• Memories live in .agents/memory at the workspace root (YAML frontmatter + markdown body)
• On-demand retrieval — when a tag or summary matches the current task, Gener reads the full memory via readFiles
• Auto-created on compact — When a conversation compacts its context window (e.g., after very long tasks), Gener distills the key decisions, state, and outcomes into a new memory entry so nothing critical is lost across sessions
• User-triggered — Type /memory in chat to instruct Gener to snapshot the current conversation's important context as a memory at any time

🔄 Exclusive Multi-Model & Seamless Switching

Control Panel - Profiles	Chat TextArea Pull Up

Gener supports a unified model selection interface across all providers with exactly the same system prompts. Switch between models instantly without reconfiguring:

• Local LLMs — Recommended/Dogfooding by llama.cpp with qwen Family as well as all other models and self-host providers
• GitHub Copilot — Copilot subscription models via proxy
• Gemini — All Gemini Pro/Flash/Ultra models
• Any OpenAI-compatible endpoint — Third-party Gateways
• Claude / Anthropic
• OpenAI
• OpenRouter

No provider lock-in. No model bundling. Just connect and go.

🎯 Exclusive Gemini Key & Model Auto-Rotation

429 is no longer a blocker. Gener's proprietary key + model pool rotation system automatically handles rate limits and server errors:

• Multi-key pooling — Configure multiple Gemini API keys; rotate seamlessly on rate limits
• Multi-model fallback — Rotate between model variants (e.g., gemini-3.8-flash → gemini-3.6-flash) when one model is throttled
• Exponential backoff — Configurable delay with Retry-After header support
• Intelligent escalation — Smart retry logic that alternates between key rotation and model rotation
• Max attempt bounds — Prevent infinite retry loops with configurable maximum attempts

[Retry Attempt 1] Key [#2](https://github.com/gener-vscode/gener/issues/2) → gemini-3.8-flash (429 → rotating...)
[Retry Attempt 2] Key [#3](https://github.com/gener-vscode/gener/issues/3) → gemini-3.6-flash (success! ✅)

📦 Zero Bundling — Gemini Models

Gener never hardcodes or bundles a fixed list of Gemini models. Instead:

1. Fetches available models dynamically from the Gemini API models.list() endpoint
2. Caches results locally (daily cached files)
3. Filters for models supporting generateContent action
4. Exposes all available models to the user in real-time

This means: new Gemini models are available immediately after Google releases them — no Gener update required.

🔓 Zero Provider & Model Dependency

Gener has no built-in provider or model dependencies. This means:

• Bring your own keys — Connect any API provider with your own credentials
• Local-first support — Run completely local models via Ollama, LM Studio, or any OpenAI-compatible endpoint
• GitHub Copilot integration — Use your existing Copilot subscription models
• Provider-agnostic architecture — Add new providers by implementing the ApiHandler interface
• No vendor lock-in — Swap providers or models at any time without breaking changes

// Supported provider types:
const providers = [
  "anthropic",     // Claude API
  "gemini",        // Google Gemini
  "openai",        // OpenAI Chat Completions
  "openai-native", // OpenAI Responses API
  "openrouter",    // OpenRouter gateway
  "ollama",        // Local Ollama
  "lmstudio",      // LM Studio
  "llama",         // Generic llama endpoint
  "ghcp",          // GitHub Copilot proxy
]

⚡ Parallel Tool Calls & Performance

Gener is engineered to stay fast even on very large, long-running tasks:

• Parallel native tool calls — Each parallel tool call executes as soon as its own streamed input JSON is complete, instead of waiting for the whole stream to end — visible results arrive earlier
• Virtualized message list — Very long task histories render smoothly instead of mounting every row
• Fingerprint-based transport — Extension → webview posts full / delta / empty state decided by a fingerprint (count / first timestamp / mutation counter), so the UI never lags on per-tick full-state posts
• Write-behind persistence — Per-tick task message persistence uses a debounced write-behind cache, eliminating MB-scale disk writes on every tick
• Structured payload — Tool content (write operations, low-stake displays, task progress) travels as structured payload with large blobs moved to raw text and unwrapped into per-item messages
• No infinity scroll and typing lag — The input box drives its own local state, so keystrokes no longer re-render the whole message list

🛠️ Rewritten Tool System

Gener's tools are designed for reliability and precision:

🌐 Browser automation is available through the bundled browser-automation skill (Playwright) and any MCP browser server — fill forms, click buttons, navigate pages, and scrape the web.

✅ File Review Journey & Checkpoints

Gener treats every file change as a reviewable, reversible action:

• Patch-based diffs — Changes are presented as reviewable accordions with line-level diffs

• Pending-review pinning — Pending edits are pinned under their original timestamps with the live streaming tail kept at the very bottom
• Bulk actions — Accept-All / Dismiss-All / Revert-All appear when multiple pending items share one type
• Git vs manual review — Review flow adapts to whether the workspace is git-managed
• Checkpoint & restore — Automatic checkpoints with one-click restore of non-git-managed files; interrupted/partial writes are marked Aborted with a terminal state
• Unread indicators — Per-operation unread dots and per-accordion pinning make it easy to track what's been reviewed
• Non-git warning — A task-header warning for unmanaged workspaces with a one-click Git Init action

🔀 Git Integration

Gener leans on Git as its safety backbone — not just optional plumbing, but the foundation under several core reliability features:

In short: Git is what makes Gener feel fearless — safe enough to let it drive without babysitting every keystroke, quiet enough not to waste tokens on junk files, and loud about it the moment protection is missing.

🧠 Skills and Commands Framework

Gener has a unified capability framework with three first-class named types, all discoverable from the same layered directory structure:

Built-in Integrated Commands: /new & /fork

Two special integrated slash commands ship natively — no file required — for managing the current task directly from chat. Both respond only while inside an ongoing conversation; sent during the initial turn they're ignored with a brief on-screen notice.

Neither can be chained or combined with any other capability in one message — attempting both in the same send surfaces a short warning explaining why only the first takes effect.

Both named types above (and these built-ins) resolve through the same layered discovery hierarchy:

Project capabilities override global, which overrides bundled; conflicts resolved at discovery time before injection.

Pre-installed skills: docx, pdf, pptx, xlsx, skill-creator, commit-message, browser-automation, image-ocr

Any capability (skill or command) can be disabled individually from Settings → Features.

Multi-Capability Prompting

Both skills and commands are invoked identically — type /name anywhere in your chat input to load that capability's instructions into the active session. Crucially, Gener supports chaining multiple capabilities in a single message: each resolves independently via the unified lookup table, loads only its own instruction body, and executes sequentially within the same task loop:

/code-review review my auth refactor, then /release-note write changelog for v0.9.38, and /vsix package it up

No need to start separate one-off tasks or copy-paste results between sessions. Describe your end-to-end workflow in one natural-language prompt, mixing any combination of project-specific commands, custom skills, and pre-installed ones — Gener carries full conversation context through every step so later commands can reference outputs produced earlier.

🔌 Rewritten MCP Integration

Full Model Context Protocol support managed through the bundled mcpc CLI:

• Connect, close, restart, login/logout, and ping MCP servers
• List and call tools, list prompts/resources/skills, and subscribe to resources
• Session-scoped management with structured logging
• Configure servers in ~/.gener/mcp/mcp.json (opened from the sidebar ⚙️/mcp button)

🤖 Autopilot Mode & Auto-Approval

Take control of how much Gener asks before acting:

• Auto-approval settings — Toggle approval for reading outside the workspace, executing all commands, and web tools
• Autopilot mode — When enabled (with the prerequisite auto-approvals on), Gener works end-to-end until reportCompletion without pausing for proposals or clarifying questions
• Plan / Code dual mode — PLAN MODE gathers context and presents proposals via presentProposal; CODE MODE executes and finishes with reportCompletion
• Per-step permission gates — By default, Gener asks for your permission at every sensitive step

💬 Live Chat Mode

• Live Chat mode — A minimal-context conversational mode (text + webSearch/webFetch/askFollowUpQuestion) that skips the full coding context for quick questions

🎯 Ask Gener — Bring Any Context Into the Conversation

It's wired directly into VS Code's surfaces:

• Editor selection — Select code and press Cmd/Ctrl + ' (or right-click → Ask Gener) to quote the selection

• Explorer files — Right-click any file/directory in the Explorer → Ask Gener to attach it
• Terminal output — Right-click in the integrated terminal → Ask Gener to capture the latest output
• Comment threads — Use "Add to Gener Chat" on an inline comment thread to bring review discussion into the conversation
• Expanded content — Select content in chat view and click the populated Attach Context button

Usage Guide

1. Select the code, file, or terminal output you want Gener to see
2. Trigger Ask Gener via the keybinding, the right-click context menu, or the ❝ quote button on any message row
3. The context is inserted as Markdown into the chat input — refine your prompt and hit send

📤 Export Conversation

Turn any conversation into a human-readable document you can share, archive, or learn from:

• Full-context export — Converts the entire context window into a clean, structured Markdown/HTML document
• Collaborate & teach — Share exports with teammates so they can pick up where you left off, review decisions, or provide guidance back to the AI
• Learning artifact — Keep a readable record of how a problem was approached and solved

🧩 Context Management & Robustness

Gener is built to stay reliable on long, complex tasks:

• Lightweight system prompts — Lean, cache-friendly prompts tuned for local and free-tier models
• Context-window overflow handling — A multi-tier degradation pipeline that preserves conversation quality as far as possible before resorting to compaction (see below)
• Automatic error retry — Up to 5 retry attempts with intelligent escalation
• Thinking-loop detection — Detects and breaks repetitive reasoning loops
• Task progress tracking — Structured, auto-completing checklists rendered from payload

How Gener Handles Context Overflow

When an active task's accumulated conversation approaches the model's context limit, Gener applies a layered, loss-minimising cascade rather than simply dropping old turns:

1. Token estimation first — Every outgoing request begins with an estimate of total tokens (all messages + system prompt). Only when this exceeds the provider's declared window does the overflow pipeline engage.

2. Live-pair preservation — The most recent user ↔ assistant exchange is spliced out and guaranteed to remain in every subsequent send. This ensures the LLM never loses sight of what you asked and its own latest reply, regardless of how aggressively older history is trimmed. If that live pair is itself anomalously large, it is gracefully converted into a compact YAML dump with a safety-net warning header instead of corrupting the entire conversation.

3. Frozen breakpoint (prompt-cache stability) — On overflow, Gener first reuses the previous truncation point if the frozen prefix still fits within budget. Because byte-identical prefixes are the key requirement for many providers' prompt-caching systems, keeping the same cut stable across consecutive API calls avoids a costly full-prefill on every turn. The result: cheaper inference and faster responses even under pressure.

4. Surgical block-level stripping — Rather than keeping or discarding whole messages, Gener runs every stale-turn content block through a role-aware filter: all assistant reasoning/narrative text survives; user-quoted content (<pre> blocks) and high-priority tool outputs are retained based on a whitelist (write_files, edit_files, presentProposal, askFollowUpQuestion, etc.). Bulky intermediate data — full file reads, dependency-graph search dumps, thinking blocks — is dropped first. The filter executes inside the signed shield WASM engine (fail-closed: if the liveness gate rejects the call the build refuses rather than silently degrading). A local reference implementation runs in shadow and logs any divergence.

5. Re-cut at earlier breakpoints — With the stripped sizes computed, Gener scans backward from the newest stale message looking for the earliest boundary whose cumulative size (stripped prefix + raw suffix) falls within half of the usable budget, so the LLM keeps as much conversation history as the window allows.

6. Force-fit & compaction — As a last resort before triggering a full compact summarisation request, Gener force-fits whatever remains into 95 % of the leftover room using progressive truncation helpers (terminal output clipping, tool-use map pruning).

7. Full compact fallback — If none of the above yields a valid context, the function returns undefined, which signals the call-site to issue a compact request: the provider receives only enough summary to continue coherently.

8. Usage transparency — After every build, Gener injects the current estimated usage (X / Y (Z%)) into the environment-details table visible to the LLM, so the model can reason about remaining headroom and the user sees the real number in debug logs.

This design keeps prompts cache-friendly by default, degrades gracefully under load, and always gives the model something coherent rather than crashing or silently losing your working state.

🎨 Completely Rebranded Webview UI

Gener kept the same gRPC/Protocol Buffers communication backbone with Cline, but rebranded every visible element of the webview UI:

• Custom React + TypeScript components — All UI components redesigned from scratch
• Tailwind CSS v4 — Modern utility-first styling with Vite integration
• Proto-driven state — Protocol Buffers maintained for efficient serialization between webview and extension host
• Unique visual identity — Distinct icons, color schemes, layouts, and micro-interactions
• Fresh UX patterns — New chat flows, settings panels, and task history views

The result: the same robust backend, a completely fresh and polished user experience.

🖥️ VS Code Exclusive Features Integration

Unlike other coding agents that target multiple IDEs and CLI, Gener is designed exclusively for VS Code to fully leverage VS Code's unique extension API surface:

• Integrated Terminal — Execute commands directly in your active terminal session with full environment context; capture remains hang-free even when VS Code's own shell-integration API goes silently broken (see Hang-Free Terminal Capture)
• Problems Panel — Auto-populate diagnostics from tool output, surfacing errors and warnings inline
• Command Palette — Seamlessly trigger Gener actions (Ask Gener, New Chat Session, History) alongside native VS Code commands
• Editor Context Menu — Right-click any file or selection to ask Gener about it
• Comment Threads — Review code changes in-place with Gener-powered inline comments
• Sidebar, Activity Bar & Standalone Window — Integrated sidebar view with custom icons and activity bar presence; undocks into its own compact auxiliary window for sidecar monitors

This deep VS Code integration means Gener doesn't just talk about your codebase — it operates within it.

🔁 Hang-Free Terminal Capture

Running a command through VS Code's shell-integration API (terminal.shellIntegration.executeCommand) normally gives an extension clean ]633;C/]633;D start/end markers and an exit-code event. That contract has a known failure mode tracked upstream at microsoft/vscode#324392: for certain command shapes — most notably multi-line scripts (an embedded literal newline inside a { … } group) or ( … ) subshells — VS Code's internal OSC‑633 parser mis-parses the command/output boundary and then delivers zero data forever: execution.read() yields nothing (not even the start marker) and onDidEndTerminalShellExecution never fires, indefinitely, while the underlying process has already exited. Any extension waiting naively on that signal hangs, and because no markers arrive there is no application-level way to detect completion.

Rather than sit indefinitely on a completion signal that VS Code may simply never emit, Gener works around this limitation internally — each command run is finalized on time and its real output is reliably recovered.

The net result is command capture that stays responsive and hang-free across normal shells, nested/SSH sessions, interactive prompts, and the very command shapes that break VS Code's own integration reporting.

🪟 Undock — Standalone Chat Window

Gener's chat can undock into its own compact auxiliary window — ideal for small or portable setups:

• Move the chat panel to a sidecar or smaller monitor, freeing up editor space on your main display
• File opens triggered from the undocked window (mentions, diff views, explorer links) route back to the main editor window
• A Dock button re-docks the standalone window back into the sidebar when you're done

🛡️ Security & Privacy

• Local-first by design — Your keys, code, and memory stay on your machine; Gener never requires an account
• Secrets protected at rest — Profiles and API keys are encrypted before they touch disk, so no secrets are ever exposed as plain text in the file system

🏗️ Installation

From Marketplace

1. Open VS Code Insiders
2. Go to Extensions (Ctrl+Shift+X)
3. Search for "Gener"
4. Click Install

⚙️ Configuration

API Keys

Configure your API keys in the Gener settings panel:

1. Click the ⚙️ gear icon in the Gener sidebar
2. Navigate to the API Configuration section
3. Enter your provider-specific keys

For Gemini auto-rotation, provide multiple keys separated by commas:

gemini_api_key_1,gemini_api_key_2,gemini_api_key_3

Semantic Index Settings

Customize the codebase indexing behavior:

• Embedding Model: Choose from OFF, minilm, jina-small, nomic, jina-code — all are tiny local models downloaded on-the-fly from Hugging Face; embeddings run entirely on your machine for full privacy at zero token cost
• Heap Limit: Set memory allocation for the indexing worker (default: 2 GB)
• Throttle: Controls per-file processing delay (default: 150ms)

Auto-Approval & Autopilot Mode

In Settings → Auto Approval, toggle:

• Read Full File System — Allow reading files/directories outside the working directory
• Execute All Commands — Skip per-command approval
• Web Tools — Allow webSearch / webFetch without prompting
• Autopilot — Run end-to-end until task completion (requires all three above)

🔑 Quick Start

1. Open your project in VS Code
2. Click the plus button (➕) in the Gener sidebar to start a new chat
3. Describe what you want — Gener will plan, propose, and execute
4. Review each step — Approve or reject tool usage as it happens

📖 Usage

Chat Commands

Keybindings

📄 License

Gener Distribution — Proprietary Freeware License

Gener as distributed is licensed under the Proprietary Freeware License © 2026 tommyli

This model ensures:

• Free to use — Anyone can install and use Gener without cost
• Full rights reserved — All source code, branding, and intellectual property remain with tommyli
• No fork risk — Prevents unauthorized forks or re-distribution under competing names

Built With Open Source

Gener is built on and ships with these open-source projects:

• Claude Code — Anthropic's open-source skill, bundled directly into Gener's skills framework
• Playwright — Powers browser automation (form filling, clicking, navigation, scraping) via the bundled browser-automation skill and MCP servers
• mcpc — The MCP client CLI behind Gener's full Model Context Protocol server lifecycle management
• optave-codegraph — The engine integrated as the backbone of Gener's dependency graph & semantic codebase index

Original Cline License — Apache 2.0

Gener is built upon Cline, which is released under the Apache 2.0 License. The conversation loop architecture was preserved and enhanced under the terms of that original license. See Cline's LICENSE for details.

🌐 Links

• Homepage: https://github.com/gener-vscode/gener