Does Samurai Agent modify my code?

No. Samurai Agent never edits your source code. All runtime analysis is performed in an isolated sandbox using test scripts only.

When should I use Samurai Agent?

Samurai Agent works best for silent bugs where logs don't explain what's wrong, complex async or state-related issues, AI-generated code that's hard to reason about, and bugs that other AI coding agents fail to fix.

When should I not use Samurai Agent?

Samurai Agent is not optimized for simple syntax errors, formatting or lint issues, or one-line bugs with obvious stack traces. In those cases, traditional linters or AI code fixes are usually faster.

Does Samurai Agent replace AI coding agents like Cursor or Copilot?

No. Samurai Agent is complementary. AI coding agents focus on writing code. Samurai Agent focuses on reviewing AI-generated code changes to catch regression risks before you ship.

Does Samurai Agent execute my code?

Yes — but only in a controlled sandbox environment. Your original files are never modified, and execution is limited to debugging purposes only.

Is my code or chat data used for training?

No. Samurai Agent does not use your code or chat conversations for training. Your source code is never stored, and debugging conversations are not retained.

Catch JS/TS regressions right after AI edits

PR review is too late. Samurai reviews AI edits the moment they happen — inside your IDE.

Open source under MIT. Nothing runs until you add a provider, a model name, and your own API key. There is no default model and no sponsored proxy.

Built for:

Install for VS Code Install for Cursor, Windsurf & more

Contribute on GitHub →

See Samurai Agent in Action

AI writes code faster than ever — but we’re left wondering what it broke. Samurai Agent is a guardrail for AI-generated code inside your IDE.

How it works

You write code with your AI coding tools (e.g. Cursor or Claude Code)

Samurai Agent automatically detects AI edits.

Samurai Agent calculates regression risk and shows a warning in your IDE.

It uses JavaScript/TypeScript-specific bug data, so detection is fast and lightweight.

Start a code review with one click.

Samurai Agent reviews the change using JS/TS bug data and runtime signals to catch regression bugs.

Samurai doesn’t replace your AI coding agent — it reviews AI-generated code to catch regressions before you ship.

What makes Samurai fundamentally different?

Samurai moves code review from PR-time to edit-time — and uses the AI's plan + JS/TS bug patterns to catch real regressions.

Edit-time review (not PR-time)

Traditional tools review after commit or pull request. Samurai reviews immediately after each AI edit — before context is lost and regressions spread.

Runs right after AI edits
No PR delay
Immediate feedback in your IDE

Plan-aware + JS/TS regression-aware

Because Samurai runs inside your IDE, it can use the AI's planning context and real JS/TS bug patterns to flag subtle logic conflicts — not generic LLM advice.

Uses AI plan + conversation context
JS/TS-specific bug patterns
Focused regression warnings

Code review hasn't evolved. AI coding has.

AI tools changed how we write code. Code review is still stuck at PR time.

Workflow	When review happens	Context available
Pull Request review	After commit	Diff-based context only
Manual review	Later (if remembered)	Human memory + limited context
Samurai (edit-time review)	Immediately after AI edits	Full IDE context + AI planning conversation + JS/TS bug patterns

Because Samurai runs inside your IDE, it can access AI planning context, analyze your full JS/TS project state, and detect subtle regression patterns — before changes reach a pull request.

Architecture for contributors

The pipeline is layered. Each stage below names what happens, whether a model is called, and where the code lives.

Edit-time flow: AI edits, detect and score, IDE warning, agent review, report

1. Edit-time detection (no LLM)

EditBurstTracker watches the editor and the filesystem (CLI tools write straight to disk). RegressionRiskScorer scores the diff with JS/TS patterns, paths, and scope — no model call. RegressionNotificationService shows the IDE warning. Files: src/services/EditBurstTracker.ts, RegressionRiskScorer.ts, RegressionNotificationService.ts.

flowchart LR edit[AI edit] --> burst[EditBurstTracker] burst --> score[RegressionRiskScorer] score --> banner[IDE warning]

2. Context the review receives

The review starts with the diff, the risk signals, and plan files from Cursor, Claude Code, Windsurf, or Antigravity (AIToolPlanDiscovery).

3. The review loop

PlanningAgent.execute repeats until a final report or timeout: thought, tool calls, or final response. RuleSelector picks prompts; ToolRegistry runs tools. Files: src/agent/core/PlanningAgent.ts, RuleSelector.ts, src/agent/tools/.

4. Tools the agent can call

Search the codebase, read git diff/history, LSP diagnostics, static analysis, graph context, sandboxed file reads, and Node runtime inspection. Original project files are never modified. Engine tools live under src/agent/tools/engine/.

5. Debugging path (separate from regression review)

Epicenter search, hypothesis generation, runtime analysis, and the root-cause report live under src/agent/tools/debugging/ and src/agent/prompts/debugging/. This is why the tree looks large — keep it mentally separate from the edit-time review path.

6. Model call (bring your own key)

LLMProviderService uses the active user entry: provider, typed model name, and API key from VS Code Secret Storage. No built-in catalog, no proxy, no sponsored tier. Files: src/agent/llm/, src/common/utils/llmSecretStore.ts.

7. Where to change it

JS/TS risk pattern → src/services/RegressionRiskScorer.ts and src/agent/tools/analysis/
Review prompt or rule → src/agent/core/RuleSelector.ts and src/agent/prompts/
New provider protocol → client in src/agent/llm/ plus the add-model form (model names are not listed in the repo)

flowchart TB ext[src/extension.ts] --> services[src/services] ext --> agent[src/agent/core] agent --> tools[src/agent/tools] agent --> prompts[src/agent/prompts] agent --> llm[src/agent/llm] ext --> webview[src/webview]

Full write-up: ARCHITECTURE.md

FAQ

Questions or feedback?

Not sure if Samurai fits your use case, or have feedback after trying it? Open a GitHub issue — contributions and questions are welcome.

Open a GitHub issue

Get Started with Samurai Agent

Install for VS Code Install for Cursor, Windsurf & more

Contribute on GitHub →