Your coding agent. Backed by your codebase.
Run Penguin’s built-in agent or connect your own. Penguin brings repository search, a code graph, and your working context into one place — so you can go from a request to a change without leaving VS Code.
Three things Penguin does differently
Not a longer feature list — three specific capabilities you can put to the test on your own repository in an afternoon.
Repository-wide context
The project, not the open file.
Index a project to make its code searchable. Penguin’s context tools combine repository search with a code graph of symbols, callers, and imports, returning relevant code with file and line references. Supported connected agents can use this context too, when context tools are enabled.
Advanced self cross-checking
Built-in agent: a second look at the evidence.
Penguin’s built-in agent uses model-based checks to assess its work. Before it reports done, a critic compares its main claims with the evidence and changes, and logs the verdict for review. You can review the verdict alongside the diff. Connected agents run their own execution and verification loops.
Fully agentic
Built-in agent: no fixed turn cap.
Penguin’s built-in agent plans steps, makes changes, runs checks, and continues until it finishes, you stop it, or it needs your help. It has no fixed turn cap; model and credit limits still apply. Saved sessions let you return to the conversation after a reload. Connected agents use their own loops and provider limits.
Your repository should outvote the training set.
A general-purpose model answers from what it saw in training — largely the average of public GitHub, not the conventions in your repository. Left to itself it reaches for the framework it has seen most often and quietly rewrites your patterns into someone else’s. That isn’t a flaw anyone chose; it’s what the training data weights toward. Penguin is built to correct for it, and here is specifically how.
Grounded in your repo, not the internet
Your architecture outvotes the training set.
The context engine maps your actual files and symbols, giving agents relevant repository evidence to work from. With context tools enabled, supported connected agents can retrieve the same project context.
Your rules outrank its habits
Write the standard down once. It holds.
Write your conventions in a rules file and Penguin follows them in every conversation. Your stack, your naming and your standards win over the model’s defaults.
No single vendor’s worldview
Pick the model. Don’t inherit its opinions.
Choose from Penguin’s available model catalogue for its built-in agent, or connect a supported agent and choose from the models it offers. Switch in the same editor; each option keeps its own billing and usage limits.
Approve the approach first
Plan mode, before a single file changes.
Plan mode lets you approve the approach before anything is written. You see what it intends to do and why, so a wrong assumption gets caught at the plan stage instead of showing up in a diff you have to unpick later.
Built for how you actually work
Bring your project context into the work, and stay in control of the changes.
Many languages, one graph
Works with about 20 programming languages, including TypeScript, PHP, Python, Go, Java and Rust. Your docs and notes are searchable too.
Grounded answers
Ask in plain language. Facts reach the model as verified lines from your repository, with file and line numbers you can open and check.
Streaming, and interruptible
Answers stream as the model writes them, and you see each file it reads and each command it runs. Queue your next message while a task runs, or press Stop to end the turn.
Undo a whole turn
Edit and resend your last message, or revert an entire agent turn with a single command. A bad direction costs you one keystroke, not a manual cleanup.
Your devices, your indexes
Sign in on every machine you code from and manage or revoke devices from your dashboard. Unindex any repository you no longer need, and re-index whenever you want it back.
Secure by design
Per-device authorization with PKCE. Approve each editor explicitly before it can act.
From a request to a checked change.
Watch Penguin trace a shared retry path, fix a bug, and run the regression checks in a local demo. Real screen recording, edited for time.
Penguin in action
Penguin’s built-in agent works through a duplicate-retry bug in a small local example, edits the shared function, and checks the regression tests. Pause or use full screen to inspect the code.
Download MP4 Read transcriptNew codebase. Find your way.
A read-only question in a small local demo codebase: Penguin retrieves the shared function and both callers, and the answer traces each call path. No files change.
Download MP4 Read transcriptFix it. Verify it.
A focused fix to the shared retry function, with both callers left unchanged, then regression tests added and run: five pass in this local demo.
Download MP4 Read transcriptRepository context
Visible tools and results
You stay in control
Your subscription. Your choice.
Use the AI subscription you already pay for. Open Settings > Your own agents to connect Claude, Codex (ChatGPT), Gemini CLI, or GitHub Copilot, then choose its model in Penguin chat.
Keep your agent. Add Penguin’s context. Your agent runs on your existing account, with Penguin’s repository search and code graph available as tools when context is enabled. Available agents and models may vary.
- 1. Connect in Settings
- 2. Choose your model
- 3. Work in Penguin
Your provider’s plan and usage limits apply. Penguin context tools that run a model use Penguin credits; lookups are free.
Your own agents in Penguin
See Your own agents in Settings and how connected agents appear in Penguin’s model selector. Provider login is handled by the provider.
Download MP4 Read transcriptHow to evaluate it in an afternoon
Don’t take the claims on faith. Point it at a codebase you already know and see whether it holds up.
Create an account
Sign up in a minute, then pick a credit package when you’re ready to run real work.
Connect VS Code
Download the extension from the Releases page in your account and authorize your editor securely.
Ask it the hardest question
Index one project, then start with the hardest question there is about that codebase. That’s the honest test.
Your code stays yours
Every editor is authorized individually with PKCE (Proof Key for Code Exchange). You approve each device explicitly, and you can revoke access or unindex any repository at any time.
No shared secrets on your machine.
Each editor is approved by you.
Cut off a device in one click.
Stop indexing a repository whenever you choose.
Index one project. Ask it your hardest question.
Put it on a repo you already know well enough to catch a wrong answer. If it gets something wrong, tell us — that's what each release is built from.