STEMCODE / LOCAL-FIRST CODING AGENT

Code faster without giving up control.

StemCode works inside your real repository: understand unfamiliar code, plan changes, edit files, run validation, review diffs, and automate pull-request feedback across terminal, desktop, editors, and CI.

GET STEMCODE ↗ EXPLORE FEATURES →

$ curl -fsSL https://raw.githubusercontent.com/rizwan3d/StemCode/master/scripts/install.sh | bash

Same stemcode command on every installer.

QUICKSTART ↗LATEST RELEASE ↗

EDITOR WORKFLOW Chat, selected context, file review, diff review, and apply suggestions without leaving VS Code. Extensions → search “StemCode” VIEW VS CODE EXTENSION ↗

ACP TOOL WINDOW A docked StemCode experience in Visual Studio, powered by the local CLI over ACP. Extensions → Manage Extensions → search “StemCode” VIEW VISUAL STUDIO EXTENSION ↗

WINDOWS · macOS · LINUX A visual workspace with chat, model controls, profiles, activity output, permission prompts, and undo/redo. Windows x64 · macOS x64/arm64 · Linux x64/arm64 DOWNLOAD DESKTOP ↗

.NET LIBRARY · NUGET Add the StemCode library to a .NET project when you want to integrate its reusable application components directly into your own code. dotnet add package StemCode VIEW STEMCODE ON NUGET ↗ The NuGet package is the StemCode library. Install the CLI with the CLI installers above.

███████╗ ████████╗ ███████╗ ███╗   ███╗  ██████╗  ██████╗  ██████╗  ███████╗
██╔════╝ ╚══██╔══╝ ██╔════╝ ████╗ ████║ ██╔════╝ ██╔═══██╗ ██╔══██╗ ██╔════╝
███████╗    ██║    █████╗   ██╔████╔██║ ██║      ██║   ██║ ██║  ██║ █████╗
╚════██║    ██║    ██╔══╝   ██║╚██╔╝██║ ██║      ██║   ██║ ██║  ██║ ██╔══╝
███████║    ██║    ███████╗ ██║ ╚═╝ ██║ ╚██████╗ ╚██████╔╝ ██████╔╝ ███████╗
╚══════╝    ╚═╝    ╚══════╝ ╚═╝     ╚═╝  ╚═════╝  ╚═════╝  ╚═════╝  ╚══════╝

◇ Thinking:

The checkout limiter is keyed only by IP. I’ll inspect the middleware, switch it to endpoint metadata, then run the API tests.

• click to collapse

◆ Running repository search: rateLimit

• Found 4 references across 3 files

— primary implementation:

11: src/api/middleware/rateLimit.ts

22: src/api/routes/checkout.ts

33: tests/api/rateLimit.test.ts

◆ Running apply_patch

• Edited 2 files (+11 −4)

— src/api/middleware/rateLimit.ts (+7 −3)

— tests/api/rateLimit.test.ts (+4 −1)

18export function rateLimit(options: RateLimitOptions) {

19 −const key = request.ip;

20 −const bucket = `${key}:${options.windowMs}`;

21return limiter.consume(bucket);

19 +const route = request.routeOptions.url ?? "unknown";

20 +const scope = options.scope ?? route;

21 +const key = `${scope}:${request.ip}`;

22return limiter.consume(key);

• tracked edit · undo available

◇ Thinking:

The limiter now separates buckets by route. I’ll run the focused tests before the full API suite.

• click to collapse

◆ Running pnpm test: tests/api/rateLimit.test.ts

• 8 tests passed in 0.9s

— validation output:

11: ✓ isolates checkout and account buckets

22: ✓ preserves custom limiter scopes

33: ✓ resets requests after the configured window

44: Test Files 1 passed · Tests 8 passed

◆ Running pnpm test:api

• API suite passed in 4.6s

— 42 passed, 0 failed

◆ Files modified (2)

Updated+7−3src/api/middleware/rateLimit.ts

Updated+4−1tests/api/rateLimit.test.ts

Implementation Configured provider AUTO Context: repo + diagnostics

LOCAL-FIRSTWorks against your real working tree.

MULTI-SURFACEDesktop, CLI, IDE, ACP, and CI.

MULTI-PROVIDERHosted, subscription, compatible, or local.

OPEN SOURCEApache 2.0 licensed.

01 — WHY STEMCODE

Powerful enough for real codebases. Transparent enough to trust.

01REAL REPOSITORIES

Your working tree is the workspace.

Search, inspect, edit, validate, and review without moving the task into a detached chat sandbox.

02VISIBLE CONTROL

Approvals stay in the loop.

Permissions and profiles decide what can run automatically, what should ask first, and what stays blocked.

03ONE AGENT

Use it where you already work.

CLI, desktop, VS Code, Visual Studio, JetBrains, ACP-compatible editors, and CI review share the same local agent.

04CODE INTELLIGENCE

Built for large codebases.

LSP-powered symbols, definitions, references, diagnostics, rename previews, and graph-aware local indexing improve context quality.

05REPO MEMORY

Knowledge you can inspect and commit.

Keep long-lived project memory in .stemcode/memory and reusable prompts in .stemcode/commands.

06TRACKED EDITS

Change code without losing the trail.

Apply targeted edits, patches, insertions, and search/replace operations with undo and redo for tracked changes.

07DIRECT SHELL

Keep commands inside the session.

Use ! for local shell commands, !! for background terminals, and Tab completion for file and directory paths.

08SUBAGENTS

Delegate without flooding the main context.

Spin up delegated tasks with independent contexts while the main conversation stays focused on the work that matters.

09INTERACTIVE QUESTIONS

Clarification is part of the workflow.

The agent can ask multiple-choice, multi-select, and free-form questions when a decision needs human input.

10LOCAL VOICE

Dictate prompts locally.

Voice dictation provides another input path without changing the repository-first StemCode workflow.

11GIT-AWARE SESSIONS

Automation stays scoped.

Automatic AI git commits can stay limited to files StemCode changed and avoid workspaces that already have staged changes.

12RELEASE VERIFICATION

Verify what you install.

Published release assets include SHA256 checksums and GitHub artifact attestations for build provenance.

STEMCODE / PRODUCT PRINCIPLE

Practical engineering work without a detached chat sandbox.

Keep the agent close to the repository, the tools, and the human decisions that matter.

02 — CAPABILITIES

From “what is this code?” to a validated change.

REPOSITORY INTELLIGENCE

Understand the codebase before touching it.

StemCode combines repository-aware search with built-in LSP-powered intelligence for symbols, definitions, references, diagnostics, and rename previews.

Focused repository search and file inspection
Symbols, definitions, references, and diagnostics
Graph-aware local codebase indexing
Planning, exploration, and review profiles

CODEBASE / INDEXREADY

Telemetry.AgentProgram.cs

WorkerHosted service

MetricsClientHTTP client

HealthChecks/healthz

12 symbols24 references0 diagnostics

TRACKED IMPLEMENTATION

Edit, run, inspect, repeat.

Use real shell tools and surgical tracked edits in the current working tree. StemCode can write files, apply patches, insert lines, search and replace, run checks, and keep changes undoable.

Whole-file writes and patch application
Line insertion and targeted search/replace
Foreground and background shell commands with ! and !!
Undo and redo for tracked agent edits

TRACKED EDITProgram.cs+5 −2

8 builder.Services.AddHostedService<Worker>();

9 − builder.Services.AddSingleton<IMetricsClient, MetricsClient>();

9 + builder.Services.AddHttpClient<IMetricsClient, MetricsClient>();

13 + app.MapHealthChecks("/healthz");

03 — ONE AGENT, MANY SURFACES

Stay in the workflow you already use.

The same local agent experience can move from interactive implementation to editor work and automated code review.

01CLI

Keyboard-first coding sessions.

Interactive work, one-shot prompts, piped input, session resume, and automation-friendly output.

stemcode

02DESKTOP

A visual workspace around the agent.

Chat, model controls, profiles, activity output, permission prompts, and undo/redo.

WINDOWS · macOS · LINUX

03VS CODE

Review and change code in-editor.

Chat, selected context, file review, diff review, and applying suggestions without leaving VS Code.

EDITOR EXTENSION

04VISUAL STUDIO

StemCode in a docked tool window.

Use the local CLI from Visual Studio through the Agent Client Protocol.

ACP

05JETBRAINS

Use the same agent in IntelliJ-based IDEs.

A JetBrains tool window powered by the local CLI over ACP.

ACP

06CI REVIEW

Automate findings-first review.

Run StemCode in GitHub Actions, GitLab CI, and Bitbucket Pipelines for proposed changes.

PR · MR · PIPELINE

07NUGET LIBRARY

Use StemCode from your .NET project.

Install the published StemCode library from NuGet when you need reusable StemCode components in application code.

dotnet add package StemCode

04 — BUILT FOR CONTROL

Automation should be visible, inspectable, and reversible.

PERMISSIONS

Allow, ask, or deny.

Control file edits, shell commands, network access, MCP tools, memory writes, and elevated operations.

PROFILES

Match behavior to the job.

Separate implementation, planning, review, exploration, and delegated work.

MEMORY

Keep project knowledge reviewable.

Store reusable commands and long-lived knowledge in versionable .stemcode/ files.

permissions.profileIMPLEMENTATION

Read filesALLOW

File editsASK

Shell commandsASK

Network accessDENY

MCP toolsASK

Memory writesASK

DiagnosticsALLOW

workspace: localtracked edits: on

05 — MODEL FLEXIBILITY

Bring the provider that fits the work.

Use subscription-style sign-in, API-key providers, OpenAI-compatible endpoints, or local-model setups.

OpenAIChatGPT sign-inAnthropicClaude sign-inGitHub CopilotOpenRouterOpenCode ZenKilo CodeCerebrasGroqDeepSeekGoogle AI StudioOllamaLM StudioOllama CloudOpenAI-compatible

06 — WORKFLOW

Use one agent from first question to final review.

Understand

Search the repo, inspect files, follow symbols, and build focused context.

Plan

Turn a bug or feature request into concrete implementation steps.

Implement

Apply tracked edits, run tools, and iterate directly in the working tree.

Validate

Run the relevant shell commands, diagnostics, and test workflows.

Review

Inspect files, diffs, pull requests, and merge requests with a findings-first workflow.

STEMCODE CREDITS

Pay for coding power. Not another seat.

StemCode stays open source. Bring your own provider or local model for a $0 platform fee, or use optional StemCode Credits for managed model access. Credit usage varies by model and workload.

01 / OPEN SOURCE BYOK

Free

$0platform fee

Run StemCode with your own API key, subscription sign-in, OpenAI-compatible endpoint, or local model.

Unlimited local StemCode usage
Desktop, CLI, IDE, and CI workflows
Your provider billing stays yours

INSTALL STEMCODE →

02 / STARTER PACK 10K

Starter

$1010,000 credits

A compact credit pack for focused fixes, reviews, and short implementation sessions.

Managed model access
Use credits across supported coding models
Top up when you need more

GET STARTER →

Builder

$2535,000 credits

More runway for everyday feature work, repository exploration, refactors, and validation loops.

3.5× Starter credits
Model choice per task
Designed for regular coding sessions

GET BUILDER →

04 / PRO PACK 100K

Pro

$60100,000 credits

For heavier coding workloads, long agent sessions, large repositories, and repeated review cycles.

10× Starter credits
Best value for high-volume use
Enterprise pooling available separately

GET PRO →

NEED SHARED CREDITS, SSO, OR CENTRAL BILLING? VIEW ENTERPRISE →

START LOCALLY

Install StemCode and open a repository.

The CLI, desktop releases, editor integrations, NuGet library, source, and documentation are all available from the public project.

01npm install -g stemcode

02cd your-project

03stemcode

OPEN STEMCODE ON GITHUB ↗