AI agents that refactor and port
your code — and prove it.
act101 is a deterministic merge gate and AST refactoring tool for coding agents: your agent does the work, then act gate classifies the change, finds the tests that reach it, diffs the side-effects, and returns a deterministic MERGE / REVIEW / BLOCK verdict with a signed receipt and one-command rollback. AI agents write code faster than anyone can maintain it — architectural drift that took five years now takes five weeks. 163 grammars, MCP and CLI, one native binary.
Agent speed is winning. Your architecture is losing.
You've watched it happen: the diff is green, the tests pass, and the structure is a little worse than it was yesterday. Not because the agent is bad — because nothing is holding the line.
Drift at agent speed
Every unreviewed agent edit adds structure nobody designed. Coupling creeps, layers blur — and the five-year rewrite cycle comes back as a five-week one.
An LLM edit is a guess
Whole-file rewrites are non-deterministic: comments vanish, formatting drifts, and behavior sometimes changes silently. You find out in review — or in production.
No undo for agents
When an agent change breaks something, recovery means git archaeology. There is no "undo the last three agent actions" — unless your toolchain keeps receipts.
Three stages. One provable change.
Analyze — 42 analyzers.
dead codecyclescouplinghotspotsseamsmap it before you touch it.
Act — 182 refactors.
renameextractinlinemovemodernizetransform it, cross-file, one invocation.
Attest — 6 verify ops + gate.
classifytests reachingside-effectsverdictreceipta deterministic verdict, not a rubber stamp.
$ act refactor extract-variable --file src/cart.ts --start-line 4 --start-column 14 --end-line 4 --end-column 35 lineTotal {"command":"refactor","operation":"extract_variable","applied":true,"changes_count":2,"files_affected":["src/cart.ts"],"impact_summary":"1 files, 2 locations, 0 references (checkpoint: ckpt-ee03fbe46f88-0000)","_meta":{"timing_ms":444,"output_tokens":52,"naive_tokens":40,"tokens_saved":0,"savings_pct":0.0,"operation_class":"write","deterministic_lines":0,"errors_prevented":0,"session":{"operations":1,"total_tokens_saved":0,"total_deterministic_lines":0,"total_errors_prevented":0,"agent_efficiency_ratio":0.0,"session_duration_ms":444}}} $ act gate act gate — working tree vs HEAD (1 changed function(s)) MERGE src/cart.ts::computeTotal — format (format-only) verdict: MERGE # extract-variable changed the text, not any modeled dimension → clears the gate $ act history undo ✓ Undid 1 operation(s); restored 1 file(s) on disk # now the agent makes a change that actually alters behavior… $ act gate act gate — working tree vs HEAD (1 changed function(s)) REVIEW src/cart.ts::computeTotal — behavior, 3 test(s) reach it (behavior change covered by 3 test(s)) verdict: REVIEW # behavior changed and tests cover it → routed to you, never auto-merged
Swipe the transcript sideways to read the full output.
Compounding debt, or compounding leverage.
Leave the loop open
Every merge you can't classify is debt at interest. Drift compounds quietly, velocity decays, and it ends in the rewrite you adopted agents to avoid.
Close the loop
Analyze, act, attest — every change classified, checked against the tests that reach it, and receipted. The codebase stays shippable at agent speed.
Who's running the agent?
Verify every refactor your agent makes — before it merges.
For the individual engineer with an agent open.
→ Codebase owner / architectSee the structural drift. Prove the refactor. On every commit.
For the people who own the shape of the codebase.
→ Open-source maintainerRunning an agent on an open-source repo? Builder is free forever.
All 18 query operations, 5 analyzers, rename and fix-auto across 138 grammars — free for open-source and non-commercial work.
→Not for solo autocomplete users. If your agent only completes the occasional line, act101 is not for you — go use your editor. It earns its keep when agents make structural changes you have to trust.
Start free with agentic refactoring. Scale when you're ready.
ast-grep and comby are free, and built for humans. So is act101 Builder Edition — free forever, and built for your agent. Engineering at $29 is the commercial tier: the full mutation toolkit, refactor verification with receipts, and a commercial license. See the measured token savings yourself.
Save ~15% with annual billing.
- 18 query operations
- 5 codebase analyzers
- Rename + fix-auto
- 138 of 163 grammars
- Non-commercial projects
Builder already beats ast-grep and comby head-to-head, free. $29 adds the commercial license and the verify-and-receipt loop your agent can branch on.
- Everything in Builder
- Extract, inline, wrap, introduce
- Generated constructors & accessors
- Refactor verification & receipts
- Commercial license
7-day free trial, all features.
Secure checkout by Paddle
- Everything in Engineering
- Structural refactors & decomposition
- Code scaffolding tools
- Whole-codebase taint + git overlays
- Team licensing
7-day free trial, all features.
Secure checkout by Paddle
- Everything in Architecture
- Legacy: COBOL, Fortran, Ada…
- Blockchain: Solidity, Vyper…
- GPU & shaders: CUDA, GLSL, HLSL, WGSL
7-day free trial, all features.
Secure checkout by Paddle
All prices USD. 7-day free trial, all features.
And because act101 answers in one call instead of reading whole files, it runs ~88% leaner on tokens, too.
Install act101. Give your AI agent real refactoring and porting tools.
Install
One native Rust binary. No dependencies, no supply chain risk, no data exfiltration.
Connect your agent
One command registers act101 with Claude Code, Cursor, Codex, Windsurf, Zed, or opencode.
Gate every change
Your agent analyzes and acts; act gate attests. Every merge gets a verdict and a receipt.
$ curl -sSL https://raw.githubusercontent.com/act101-ai/act101/main/install.sh | sh
PS> irm https://raw.githubusercontent.com/act101-ai/act101/main/install.ps1 | iex
Install it straight from the marketplace, or set it up directly in your tool.
$ claude plugin marketplace add act101-ai/act101
$ claude plugin install act101@act101-marketplace
$ act install cursor
$ codex plugin marketplace add act101-ai/act101
# Then in any Codex session: /plugins → act101 → Install
$ act install windsurf
$ act install zed
$ act install opencode
Source, releases, and issue tracker on GitHub: github.com/act101-ai/act101 →
An AI-Code Health Score for the repos your agent writes.
act101 online is the GitHub-native health scanner for AI-authored code: one grade, two halves — Security and Architecture. It runs in GitHub Actions and lands results where you already work — as a PR comment, a Check Run, and a SARIF upload that opens code-scanning alerts. Free for public repos.
Built by an engineer who's spent a career on software that has to be correct
act101 was born out of decades of production experience across financial services, geospatial, automotive, medical devices, and biotech. In 1999, Refactoring and the tools it inspired turned code maintenance from a risky manual art into a mechanical, safe activity — act101 brings that same discipline to coding agents. It's the procedural verification layer built to make them trustworthy: every edit an agent makes is classified, tested against the code that reaches it, and gated before it can merge. Read the story →
The questions engineers actually ask.
Can an AI agent actually refactor my Python codebase with act?
Yes. act ships as one native binary with two interfaces — MCP and a CLI — both exposing the same 182 AST-aware refactor operations. Agents like Claude Code, Cursor, Codex, and OpenCode call rename, extract function, inline, move symbol, convert-to-dataclass, add-type-hints, and 60+ Python-specific refactors directly, with cross-file import updates, automatic checkpoints, and instant undo.
Can an AI agent port a C codebase to Rust?
Yes. act provides 10 porting operations — port_contract,
port_inventory, port_order, a port_manifest state
machine, and cross-language adapter/shim generators — that let an agent define a
source-to-target contract, inventory every symbol that must move, resolve dependency
ordering, and track the migration step by step. The same workflow handles Ruby to Elixir,
COBOL to Java, Python 2 to Python 3, and arbitrary pairs across 163 grammars.
Is cross-language porting production-ready?
Porting is a workflow, not a button. The 10 porting operations plus parity
verification make each step checkable — the manifest keeps score, and
verify_port_parity checks that a ported function behaves like the original.
Small, well-tested modules port well today. A large legacy migration is a program of
work run step by step under the manifest — that's what the Enterprise engagement covers.
Evaluate the claim the cheap way: port one module and read the parity report.
How is act different from ast-grep, comby, or semgrep?
ast-grep, comby, and semgrep are pattern-matching and structural search tools designed for humans. act is one native binary that exposes typed, parameterised refactor operations through MCP and a CLI, with automatic checkpointing, instant undo, and a merge gate that returns a verdict and a receipt. Full comparisons: act101 vs ast-grep · act101 vs comby · act101 vs semgrep.
How real is the ~88% token saving?
It's measured, not estimated: ~88% fewer tokens on query operations — skeleton, references, callers — versus reading whole files, from timed runs against real repositories. The method and the raw numbers are published. It applies to reads, not writes, and it's a side effect of answering from the AST instead of shipping whole files — the product's job is the verdict and the receipt.
Which AI coding agents work with act?
act is one native binary that is both an MCP server and a CLI. Run
act mcp serve and Claude Code, Cursor, OpenAI Codex, and OpenCode connect
via stdio or HTTP+SSE — or run any act subcommand directly. Marketplace install blocks
for each agent are in the install section.
Not ready to install?
Take Continuous Quality with Agents — the playbook for gating every push on the health of the code, not just its behavior. Confirm your email and the PDF lands in your inbox, along with occasional ship notes.
No spam; unsubscribe anytime · Privacy
Your agent shouldn't ship code without proving it preserves behavior.
Install free.
Run agentic code transformation on your codebase.
Close the loop on quality.
7-day free trial, all features.
Free forever for personal use · $29/mo commercial.
Works with every local agentic coding platform.
Larger rollout? Contact sales.