VS Code Extension · Public Beta

AI Test Generation
Right in your VS Code

Install the KeelTest VS Code extension and right-click any Python file to generate comprehensive tests. If pass rate is under 70%, you don't pay a cent.

Watch Demo

Free extension · VS Code Marketplace · 7 free credits/month

Test Generation
Target File
python/easy/string_utils.py
Completed successfully
Pass rate:100%
Tests passing:30/30 (100%)
Time:1m 12s
✓
Code analysis
✓
Initial generation
✓
Working on functions
✓
Finished
Recent activity▼
Working on function 3/4: testing truncate...
Working on function 4/4: generating tests...
Working on function 4/4: testing count_words...
Fixing failures (attempt 2/3)...
Running final test suite...
1def reverse_string(text: str) -> str:
2    """Reverse a string."""
3    if not text:
4        return ""
5    return text[::-1]
6
7def is_palindrome(text: str) -> bool:
8    """Check if a string is a palindrome."""
9    if not text:
10        return False
11    cleaned = text.lower().replace(" ", "")
12    return cleaned == cleaned[::-1]
13
14def truncate(text: str, max_length: int) -> str:
15    """Truncate string to max length with ellipsis."""
16    if len(text) <= max_length:
17        return text
18    return text[:max_length - 3] + "..."
19
20def count_words(text: str) -> int:
21    """Count words in a string."""
22    if not text or not text.strip():
23        return 0
24    return len(text.split())
✓
Tests generated
test_string_utils.py
30/30 passing (100%)·1m 2s
Install from VS Code Marketplace

Get Started in 3 Simple Steps

KeelTest is a VS Code extension that installs in seconds. No complex setup, no external services.

1

Open VS Code Extensions

Press Ctrl+Shift+X (Windows/Linux) or Cmd+Shift+X (Mac) to open the Extensions view in VS Code.

2

Search for KeelTest

Type "KeelTest" in the search bar and click Install on the official KeelTest extension.

3

Right-Click and Generate

Right-click any Python file in your workspace and select "KeelTest: Generate Tests" to start.

Free to install • Available on VS Code Marketplace • No credit card required

Everything you need to
test with confidence

Our VS Code extension uses advanced AI to handle the tedious parts of testing so you can focus on building features.

Deep Static Analysis

We analyze control flow, variable boundaries, and cyclomatic complexity to generate tests that cover edge cases others miss.

Free to Start

Get 7 free credits every month. No credit card required.

Smart Dependency Mapping

KeelTest identifies function roles (DB, API, Service) and automatically mocks external dependencies.

Linter-Compliant Output

Generated code is auto-formatted and linted (Ruff) to match your project's strict standards.

Self-Healing Tests

If a generated test fails, our AI analyzes the error and fixes it automatically before you even see it.

See it in action

From Code to Tests in 3 Clicks

KeelTest Demo - VS Code

Simple, Transparent Pricing

Start free today. Paid plans are coming soon.

Join 64 developers waiting for Pro & Team plans.

Individual

Free

$0/month

Perfect for trying it out

7 credits/month

  • Priority queue access
  • Usage analytics
4x

Pro

Recommended
$9.99/month

For daily development

30 credits/month

  • Priority queue access
  • Usage analytics
10x

Ultra

$19.99/month

For power users

70 credits/month

  • Priority queue access
  • Usage analytics
  • Early access to features

Business

Small Team

$24.99/month

2-5 developers

Up to 5 seats

100 credits/month

  • Team management
  • Centralized billing
  • Priority support

Team

Recommended
$59.99/month

6-15 developers

Up to 15 seats

300 credits/month

  • Team management
  • Centralized billing
  • Priority support

Enterprise

Custom

Unlimited scale

Unlimited seats

Custom allocation

  • SSO & Security
  • Custom SLAs
  • Dedicated support

How It Works

Credits System

1 credit = 1 small file (up to 15 functions)

Larger files use more credits proportionally. Credits reset monthly. Free plan gets 7, Pro gets 4x more (30), Ultra gets 10x more (70).

Pass Rate Guarantee

Tests are automatically run before delivery

We guarantee 70%+ pass rates. Self-healing included - failing tests are auto-fixed. You only see production-ready code.

Python First

Full support for Python + pytest

More languages coming soon. Our AI understands Python libraries, async code, and generates idiomatic tests.

Monthly credit resets
Cancel anytime
Keep generated tests forever

Real Pass Rates, Not Guesses

Every test is run before you see it. No surprises, no broken code.

Failing tests are auto-fixed before delivery

See real pass rates, not marketing claims

Credit Examples

See how far your credits can go

Free
7
credits/month
Small files (≤15 fn)~7
Medium files (~30 fn)~3
Large files (~50 fn)~1
Best Value
Pro
30
credits/month
Small files (≤15 fn)~30
Medium files (~30 fn)~15
Large files (~50 fn)~7
Ultra
70
credits/month
Small files (≤15 fn)~70
Medium files (~30 fn)~35
Large files (~50 fn)~17

💡 1 credit = up to 15 functions. Larger files use proportionally more credits. All plans include unlimited test runs and self-healing.

Independent Benchmark Results

Beyond Raw LLM Power

We tested leading AI models on generating unit tests for complex e-commerce logic. KeelTest's agentic approach-combining AI with static code analysis, test validation, and actual execution-achieved a staff-level score of 8.5/10, outperforming pure zero-shot prompts by 54%.

Overall Quality ScoreStaff Engineer = 10

Model D (KeelTest Agentic)(Agentic AI + Static Analysis)
8.5/10
Model B (Claude Sonnet 4.5)(Zero Shot)
5.5/10
Model C (Grok Auto)(Zero Shot)
3.5/10
Model A (GPT 5.1)(Zero Shot)
2.5/10

Detailed Evaluation Criteria

CriteriaModel DModel BModel CModel A
Unit Test Isolation
Mocking & Dependency Injection
Edge Case Coverage
Following Instructions
Technical Correctness
DateTime/Float Precision
Excellent
Partial
Poor/Missing
8.5/10
KeelTest Score
Staff Level
54%
Better Than
Best Zero-Shot
100%
Unit Test Isolation
Proper Mocking
95
Tests Generated
All Passing

"Model D demonstrates the deepest understanding of unit testing principles with proper isolation, comprehensive mocking, and dependency injection. It's what a staff engineer would produce."

* KeelTest leverages advanced AI models enhanced with static code analysis, automated test validation, and real-time execution feedback-not just raw prompts.

Frequently Asked Questions

We are honest about it. If the generated test suite has a pass rate lower than 70%, we don't charge you a credit. For suites that pass >70%, we mark failing tests clearly so you can fix them quickly-most users clean them up in a few minutes and still save hours compared to writing tests from scratch.
Because you paid for comprehensive coverage. Failing tests often reveal real edge cases or bugs in your code. They are valuable signal for understanding your system, even if they need a small amount of manual fixing before you commit them.
We use a simple tier-based system. Small files (1-15 functions) cost 1 credit. Medium files (16-30 functions) cost 2 credits. Your credits reset every 30 days based on your plan (10 for Free, 30 for Pro, 100 for Teams).
We use a specialized KeelTest agent powered by OpenAI's models. It understands business logic, mocks side effects intelligently, and writes production-grade pytest code. We no longer offer a 'fast' mode because we believe quality is non-negotiable.
Currently Python with pytest. We are always looking for ways to support more languages.
Full refund within 14 days if you're not satisfied. No questions asked.
Yes, you can switch plans at any time. If you upgrade, you'll get the difference in credits immediately. If you downgrade, your new limit will apply at the start of the next billing cycle.