act101 Review: AST Refactoring and Attestation for AI Coding Agents (2026)

Opening

Your agent just renamed a method. It touched twelve files. Three call sites still compile only because luck and grep saved you. You burned four dollars in tokens re-reading the repo, and when your tech lead asks what actually changed, you have a diff—not a proof that behavior stayed the same.

That gap—generation without verification—is where act101 plants its flag. act101 (currently act 2.0.2) is a native Rust binary that exposes AST-aware refactor, query, analysis, and porting operations to AI coding agents through a built-in Model Context Protocol (MCP) server. The product thesis, stated plainly on the About page: "The bottleneck of agentic software is not generation. Agents generate. The bottleneck is proof."

This act101 review walks through what the tool actually does, how it differs from letting Codex or Claude rewrite files, who should pay for Engineering vs. Architecture tiers, and where honest skepticism still applies—especially on cross-language porting and enterprise modernization claims.

Key takeaways

• act101 is infrastructure for agents, not a chat UI—install a binary, wire MCP into Claude Code or Cursor, invoke typed operations.
• Refactors are deterministic AST transforms with checkpoint/undo—not probabilistic whole-file rewrites from an LLM.
• The analyze → act → attest workflow produces verifiable receipts so supervised agents can show what changed and what contract was preserved.
• Best for staff engineers and platform teams running agents on large or legacy codebases; overkill if you only need occasional autocomplete.

What is act101?

act101 is a code quality and refactoring suite built for AI agents and the engineers who supervise them. At its core sits act, a CLI that speaks MCP over stdio (local agents) or HTTP+SSE (remote clients). Agents call parameterized tools—rename, extract-function, move-symbol, coupling analysis, dead-code detection—instead of improvising edits from raw text.

The scale of the catalog, per act101's public documentation:

• 163 AST-based grammars
• 183 refactor operations (language-specific)
• 41 codebase analyzers
• 15 query operations (symbols, references, callers, control flow, repo outline, etc.)
• 10 porting operations (contract / inventory / ordering / manifest for migrations)
• 21 pre-built agent skills (architecture audit, migration assessment, change-impact, health-check, and similar)

The positioning against ast-grep, comby, and semgrep is intentional: those tools excel at pattern matching for humans. act101 targets parameterized refactors with cross-file consistency, checkpointing, and undo—operations an agent can chain without re-parsing the entire repository each turn.

If you searched "act101 review" after seeing the Launchpadly listing tagline—analyze. act. attest.—read it literally. Analyze the codebase structurally, act with procedural transforms, attest that the result matches the intended contract.

Product overview

The MCP integration path

Setup is deliberately boring—in a good way. Install the binary, then register MCP:

act mcp serve          # stdio — Claude Code, local Cursor, etc.
act mcp http --host 127.0.0.1 --port 10101   # HTTP+SSE for remote clients

Claude Code users add to ~/.claude/settings.json:

{ "mcpServers": { "act": { "command": "act", "args": ["mcp", "serve"] } } }

Once connected, agents invoke catalog operations by intent: agent refactor python, agent port c to rust, agent analyze coupling, agent dead code analysis. The docs publish canonical phrasing so agent harnesses route structural work to act instead of freestyle editing.

Why procedural beats probabilistic (for refactors)

act101's About page contrasts two paths to the same job—changing a method signature across callers:

Approach	Character
Agent freestyle	Non-deterministic, token-heavy, opaque; may miss call sites
act101 invoke	Single tool call; 25 files updated in one invocation with receipt + rollback

That table is marketing, but the underlying claim is technically meaningful. Rename and extract-function are classic IDE refactorings because they require symbol graphs, not clever prose. LLMs approximate that graph by reading text; act101 computes it from ASTs. For multi-file consistency, the difference between "probably got them all" and "operation completed with references resolved" is the difference between a PR you merge nervously and one you merge with evidence.

analyze → act → attest

Every workflow shares one shape:

1. Analyze — query and analyzer tools map structure: coupling, cycles, hotspots, module boundaries, migration readiness, taint surfaces (tier-dependent).
2. Act — refactor and mutation tools apply transforms with checkpoints; undo is instant relative to re-prompting an agent.
3. Attest — verification and receipts document what changed relative to the contract the operation promised to preserve.

The founder narrative on About is unusually candid: act101 emerged from needing to prove agent-driven changes before merging million-plus line codebases shipped under license. The product is, in their words, "the recursion: what I shipped is the toolchain I needed to ship it." Whether or not you share that scale, the design goal is clear—supervised autonomy, not blind autonomy.

Key features

AST refactor catalog (183 operations)

Operations span everyday hygiene (rename, inline, extract-function, move-symbol) and language-specific transforms (convert-to-dataclass, extract-trait, generated constructors/accessors on paid tiers). Each grammar has a per-language operation reference in the docs—important because "rename" in Python and "rename" in Rust do not share identical edge cases.

Query layer (15 operations)

Before mutating, agents need ground truth: skeleton views, symbol tables, reference graphs, caller lists, control-flow summaries, mutation sites, type queries, repo outlines. act101 treats queries as first-class MCP tools rather than asking the LLM to re-read files and hallucinate structure.

Analysis layer (41 analyzers)

Deeper passes cover coupling, dependency cycles, dead code, hotspots, module boundaries, and migration readiness. Architecture Edition adds whole-codebase taint, effect closure, and git/production overlays (churn, coverage, ownership)—the kind of context staff engineers stitch together manually before a risky split.

Cross-language porting (Enterprise tier)

Porting operations implement a state machine: contract → inventory → ordering → manifest. Public examples include C to Rust, Ruby to Elixir, COBOL to Java, Python 2 to Python 3, and arbitrary source/target pairs across supported grammars—without rewriting entire files in one LLM shot.

This is the boldest claim in the product. Legacy modernization buyers should treat porting as evaluation-heavy: parity verification and migration composites are Enterprise-only for a reason. Pilot on a bounded module before betting a program budget.

Agent skills (21 workflows)

Pre-built patterns—architecture-audit, code-review, refactoring, migration-assessment, boundary-analysis, change-impact, health-check, code-navigation, code-generation, architectural-refactoring—give agents multi-step playbooks instead of one-off tool calls. Skills are how act101 productizes senior-engineer workflows for repeatable agent supervision.

History, checkpointing, undo

Operation history with list/undo/redo turns agent sessions into ** reversible edit streams**. When an agent goes down a wrong path, rolling back a checkpoint beats reverting git commits scattered across a long autonomous run.

Who should use act101

• Engineers running Claude Code, Cursor, Codex, or OpenCode daily who want agents to call tools instead of editing raw text for structural tasks.
• Staff and platform engineers responsible for large refactors—module extractions, rename storms, API surface changes—where missed references are expensive.
• Architecture and modernization leads evaluating coupling, boundaries, and migration readiness before splitting monoliths or replatforming.
• Regulated-domain teams (finance, medical devices, automotive—domains the founder cites) where audit trails and attestations matter as much as velocity.
• Open-source maintainers on non-commercial work who can start on Builder Edition ($0) with queries, rename, fix-auto, and five analyzers.

Who should avoid it

• Developers who do not use MCP-connected agents—act101 is additive infrastructure, not a standalone IDE replacement.
• Small codebases with rare refactors—your language server + IDE rename may be enough; act101 shines when agents multiply edit volume.
• Teams expecting act101 to replace tests or CI—receipts and verification supplement; they do not eliminate the need for your test suite.
• Buyers who need porting parity on a budget—full porting ops + parity verification sit in Enterprise (contact sales), not the $29–$99 self-serve tiers.
• Organizations allergic to native binaries—you are installing and licensing a Rust CLI, not a pure SaaS web app.

Pricing and value

act101 publishes clear USD pricing (monthly; annual billing available) with a 7-day free trial on all features:

Edition	Price	Highlights
Builder	$0 forever	18 query ops, 5 analyzers, rename + fix-auto, 138 grammars; personal / non-commercial / OSS
Engineering	$29/mo	Full mutation toolkit, refactor verification & receipts, commercial license
Architecture	$59/mo	Structural refactors, scaffolding, taint + git overlays, team licensing
Elite	$99/mo	Architecture plus 25 premium grammars (COBOL, Fortran, Ada, Solidity, CUDA, WGSL, etc.)
Enterprise	Contact sales	Porting ops, parity verification, modernization programs
Fleet	Contact sales	Agent fleet licensing by concurrency/tenant

Value framing: At $29/month, Engineering Edition costs less than a few hours of senior engineer time lost to a bad agent-led rename. Architecture at $59/month is rational if you are about to spend a sprint on decomposition work and want analyzers that agents can invoke consistently. Elite's premium grammars target a narrow but high-stakes buyer—mainframe, HDL, blockchain—where tooling scarcity already commands budget.

Builder Edition is genuinely useful for evaluation and OSS maintainers; it is not a crippled demo. The commercial license line at Engineering is the natural upgrade trigger for startups shipping paid products.

Pros and cons

Pros

• Deterministic refactors address the core failure mode of agentic coding: structurally wrong edits that look plausible in diff view.
• MCP-native fits the direction of Claude Code, Cursor, and the broader agent ecosystem—meet tools where agents already live.
• Massive grammar and operation catalog reduces one-off scripting across polyglot repos.
• Checkpoint/undo makes agent sessions recoverable without git archaeology.
• Attestation/receipts align with emerging audit expectations for AI tool use in serious engineering orgs.
• Transparent tier matrix on the pricing page—buyers know what unlocks where.

Cons

• Setup and mental model overhead—MCP wiring, edition limits, and operation catalogs take time before payoff.
• Porting and parity at Enterprise—the headline "163 languages" story is real for analysis; full migration proof is enterprise sales cycle.
• Agent quality still matters—act101 gives better tools; it does not stop a agent from ignoring them.
• Overlap with IDE refactors for single-file, human-driven edits—act101 wins at agent scale and cross-file ops, not every keystroke.
• Native binary dependency—CI and fleet deployments need install/licensing discipline (Fleet tier for scale).

Real use cases

A platform team migrating Python 2 remnants uses query tools for repo outline and migration readiness, then Engineering-tier extract/inline/rename operations with receipts attached to the PR—reviewers see attestation metadata, not only a wall of LLM-generated diff.

A fintech shop supervising Claude Code on a monolith registers act mcp serve, routes signature changes through act101 instead of chat edits, and uses coupling + cycle analyzers before extracting a payments module behind a boundary.

An enterprise modernization program evaluating COBOL → Java pilots Elite grammars for inventory/analysis, then engages Enterprise for porting ops and parity verification on a bounded subsystem—treating act101 as execution infrastructure, not a magic translator.

How it compares in Developer Tools

The agent tooling landscape splits into three buckets:

1. General coding agents (Cursor, Claude Code, Codex) — excellent generation, weak guarantees on structural edits.
2. Pattern tools (ast-grep, semgrep, comby) — excellent search/replace rules, not parameterized multi-file refactors for agents.
3. IDE refactors — excellent for human-driven, language-server-backed edits; poorly exposed to autonomous agents at scale.

act101 occupies a fourth slot: agent-callable, AST-grounded refactor and analysis infrastructure with optional attestation. It is closest in spirit to giving your agent a senior engineer's refactoring IDE—headless, scriptable, and MCP-wired.

It does not compete with GitHub Copilot autocomplete or with running cargo clippy. It competes with the hours you lose when an agent "refactors" by rewriting files and you become the test suite.

Verdict

act101 is one of the most serious answers yet to a question many teams are still hand-waving away: what happens after the agent edits your production code? The analyze → act → attest loop, the MCP server design, and the sheer breadth of grammars and operations read like software built by someone who has shipped under constraints—not someone pitching "AI dev tools" from a slide deck.

We recommend a structured trial: install Builder Edition, wire MCP into your primary agent, and force structural tasks (rename across modules, extract function, coupling report) through act for two weeks. If receipts and single-invocation multi-file updates save you even one bad merge, Engineering ($29/mo) pays for itself.

Skip it if you are not yet running agents on real repos, or if your problems are formatting and lint—not graph-aware change. Call sales for Enterprise only when you have a defined modernization scope and budget for parity proof, not curiosity.

The product name encodes the workflow—act101: analyze, act, attest. For teams treating agent output as production input, that third step is not optional. act101 tries to make it mechanical.

FAQ

Does act101 replace my AI coding assistant?

No. It extends Claude Code, Cursor, Codex, or OpenCode with MCP tools for structure-aware refactors and analysis. The LLM still plans; act101 executes deterministic transforms and records evidence.

How do I connect act101 to Cursor or Claude Code?

Install the act binary, then add an MCP server entry pointing to act mcp serve (stdio) or run act mcp http for HTTP+SSE. act101's docs include a Claude Code JSON snippet; Cursor supports MCP servers through its settings UI.

Is the free Builder Edition enough to evaluate?

Yes for non-commercial / OSS work: queries, rename, fix-auto, and five analyzers across 138 grammars. Commercial products need Engineering ($29/mo) or higher.

Can act101 port COBOL to Java automatically?

Porting operations and parity verification are Enterprise capabilities. Elite ($99/mo) adds premium grammars including COBOL; full migration programs expect a sales conversation and bounded pilots—not one-click magic.

What is a refactor "receipt"?

In act101's model, receipts document what operation ran and what behavioral contract it attests to—part of the verify_* suite on paid tiers. Treat receipts as audit artifacts for supervised agent workflows, not a substitute for your test pipeline.

act101 vs ast-grep or semgrep?

Pattern matchers find code; act101 applies typed refactors and cross-file symbol operations designed for agents, with undo and verification. Use semgrep for policy rules; use act101 when an agent must change structure reliably.