Gemini-GPT Hybrid
Claude Code subagents that route big-context work to Gemini and fast iteration to GPT, then gate output through Claude.
- Source repo
- oesoll/gemini-gpt-hybrid
- Stars
- ★ 153
- Last updated
- 3mo ago
- License
- MIT
- FA score
- 30/100 · Major gaps
At a glance
- Works with
- Platform-specificClaude Code
- You'll need
- Typical use
- A developer inheriting an unfamiliar repo who wants Gemini to hold the whole codebase in context for a security audit or architecture review.
- Main limitation
- Tied to Claude Code as the runtime; the deliverable is Claude Code subagent Markdown and does not transfer to other agent clients as-is.
- Source review
- 30/100 · Major gaps 2 safety controls not found
What does this agent do, and when should you use it?
Gemini-GPT Hybrid is a multi-model orchestration layer delivered as Claude Code subagents. The repository ships two Markdown agent definitions in agents/ — gemini-gpt-hybrid-soft.md and gemini-gpt-hybrid-hard.md — installed by copying that directory into ~/.claude/agents/. When invoked with @gemini-gpt-hybrid, the agent reads the scope of the request and delegates: whole-repo audits, architecture reviews and sweeping refactors go to Gemini for its 1M+ token context; single-file debugging and focused features go to GPT for faster turnaround; mixed requests use both in sequence. The two variants differ only in write permission: soft mode lets external models analyze while Claude writes and reviews every change; hard mode lets external models modify files directly with no Claude gate before the write. It requires Claude Code, the Gemini CLI and Cursor Agent for GPT, with WSL on Windows, and is MIT licensed.
The subagent inspects the request's scope signals and picks a route: large-scope work goes to the Gemini engine, focused work to the GPT engine, and mixed requests chain both. Anything that produces code passes through a Claude review pass — a security audit of injection surfaces, authentication paths, data exposure and input validation, followed by a quality pass over structure, error handling and performance characteristics — and only approved output is written to disk; rejected output enters a refinement loop. In the soft agent, Gemini and GPT never touch your files and only emit analysis; the hard agent skips that gate and lets external models edit the codebase directly. Distribution is plain Markdown agent files under ~/.claude/agents/.
- A developer inheriting an unfamiliar repo who wants Gemini to hold the whole codebase in context for a security audit or architecture review.
- An engineer chasing one authentication bug in a single file who needs a fast fix loop rather than whole-repo reasoning.
- A task that starts as architecture analysis and ends in implementation, which needs both models run in sequence.
- A team prototyping on a throwaway branch that wants maximum speed and accepts a Git commit as its rollback.
- A team with strict coding standards on production code that wants every write reviewed by Claude and by a human reading the diff.
How do you install or deploy this agent?
Prerequisites: Claude Code, the Gemini CLI, and Cursor Agent for the GPT integration. On Windows you also need WSL.
Install the Gemini CLI:
npm install -g @google/gemini-cliClone the repository and copy the agents into Claude Code's agent directory (macOS / Linux):
git clone https://github.com/NEWBIE0413/gemini-gpt-hybrid.git
cd gemini-gpt-hybrid
cp -r agents ~/.claude/On Windows:
xcopy agents %USERPROFILE%\.claude\agents\ /E /IVerify the install:
ls ~/.claude/agents/You should see both agent files listed.
How do you use this agent?
Mention the agent in a Claude Code conversation and describe the task; scope decides the route.
Large scope — delegated to Gemini:
@gemini-gpt-hybrid perform a security audit on the entire codebaseNarrow scope — delegated to GPT:
@gemini-gpt-hybrid debug the authentication issue in login.jsMixed scope — both models, in sequence:
@gemini-gpt-hybrid analyze the architecture and implement improvementsBefore using hard mode, commit and branch so you have a rollback point:
git add -A && git commit -m "Backup before hard mode"
git checkout -b experimentalWhat are this agent's strengths and limitations?
- The model choice is an explicit, readable routing table in the agent definition, not a black box: whole-repo work to Gemini's 1M+ token context, narrow fixes to GPT.
- Two documented write-permission tiers — soft keeps every file write with Claude after a review pass, so external-model output cannot land unreviewed.
- Zero infrastructure: installation is copying Markdown files into ~/.claude/agents/, with no server, database or build step.
- The review pass is itemized (injection surfaces, auth paths, data exposure, input validation, structure, error handling, performance) rather than a vague 'Claude checks it'.
- Tied to Claude Code as the runtime; the deliverable is Claude Code subagent Markdown and does not transfer to other agent clients as-is.
- The GPT path depends on Cursor Agent, adding another third-party product to the dependency chain.
- Hard mode lets external models overwrite files with no Claude gate; the README states a clean Git commit is the only reliable rollback.
- The review pass is explicitly not a guarantee — it catches common problem classes and still requires reading the diff yourself.
- Windows support runs through WSL per the prerequisites; no native Windows path is described.
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Gemini-GPT Hybrid This agent | 30 · Major gaps | — | ★ 153 | 3mo ago | — | Claude Code |
| Maestro Orchestration Platform | 75 · Some gaps | Agent plugin / skillFree + model costs | ★ 486 | 16d ago | JavaScript | Codex · Claude Code |
| Pilotfish Multi-Model Orchestration | 81 · Good | Agent plugin / skillFree + model costs | ★ 715 | 26d ago | Python | Claude Code |
| Crewplane | 73 · Some gaps | CLIFree + model costs | ★ 48 | 2d ago | Python | Codex · Claude Code |
How does FollowAgents rate this agent?
Why each dimension lost points
README distinguishes soft/hard modes where soft lets Claude write and hard lets external models write directly, showing some write-permission differentiation (least_privilege 1; hard mode grants direct external writes without code-level constraints, so not higher). User confirmation is only a documented suggestion to commit first, with no enforced confirmation (1). Data-flow transparency relies on a mermaid diagram and table; it does not specify what data is sent to Gemini/GPT or third-party transmission details (1). Sensitive data handling is entirely absent—no mention of keys, credentials, or code exfiltration risk (0). Dependency security lists peerDependencies with wildcard '*' versions and no lockfile or audit (0). External effects: hard mode can overwrite files, warned only in docs with no technical guardrail (1). Rollback is only a git-commit suggestion, no automated rollback (1). Source attribution names an author and models, but LICENSE copyright ('Claude AI Agents Contributors') conflicts with README author (Seol Seunghyeon), weakening attribution (1).
The routing table and mermaid diagram are broadly self-consistent, but the actual agents/ files are not provided, so soft/hard descriptions cannot be verified against implementation (self_consistency 1). Dependency availability uses wildcard '*' peerDependencies and vaguely describes Cursor Agent as a GPT prerequisite, making install feasibility uncertain (1). Failure messages are entirely absent—no error handling or failure-notice documentation (0).
README provides production/experiment scenarios and a soft/hard selection table, giving decent audience and scenario coverage (2). Capability boundaries are only a single line ('review layer, not a guarantee'); model limits and routing-failure cases are undefined (1). Trigger precision depends on natural-language scope judgment with no explicit thresholds or rules (1). Environment fit mentions WSL and macOS/Linux/Windows install commands but these are unverified (1).
Information architecture links README, AGENT_SELECTION_GUIDE, CONTRIBUTING, etc., but most files are not in the evidence (1). Install notes are fairly complete with prerequisites and multi-platform commands (2). Naming stability: package.json name matches README, but the repo URL points to NEWBIE0413 while the object is oesoll—an inconsistency (1). Examples cover basic usage but there is no FAQ (1). Known limitations mention only hard-mode risk and review non-guarantee (1). LICENSE is a full MIT text (2). No CHANGELOG or version history; package.json is only 1.0.0 (0). Maintenance responsibility is unclear with conflicting author attribution (1).
Output usability describes a Claude-review-then-write flow but gives no actual artifact examples (1). Marginal value: multi-model routing is an appealing claim but lacks comparative evidence or benchmarks (1). Cost-benefit mentions speed/risk tradeoffs but does not quantify token cost or latency (1).
claim_traceability is absent—claims like 1M tokens and speed have no cited sources (0). cross_source_corroboration cannot be done because agents files and scripts are not provided (0). fact_inference_separation is slightly present, e.g., README distinguishes 'review layer, not a guarantee' (1).
- Not found in source: sensitive-data handlingUse dedicated, low-privilege, revocable API keys — never production credentials — and keep secrets out of logs.
- Not found in source: dependency securityPin versions and run a dependency audit (npm audit, pip-audit) before installing; prefer running it in a container.
- Hard mode lets external models directly modify the codebase with only a documented 'commit first' suggestion and no technical guardrail, risking overwritten work.
- peerDependencies use wildcard '*' with no locked versions or dependency audit, making install reproducibility uncertain.
- LICENSE copyright conflicts with the README author, and the repo URL points to NEWBIE0413 rather than oesoll, leaving attribution and maintenance responsibility unclear.
- The agents/ files and scripts are not provided in the evidence, so routing logic and soft/hard descriptions cannot be verified against implementation.
- It does not specify what data is sent to Gemini/GPT or third-party transmission details, leaving sensitive code exfiltration risk unaddressed.