act is the first dev tool that lets an AI agent actually do language-aware code work — agent refactor Python, agent port C to Rust, agent port Ruby to Elixir, agent port COBOL to Java. 163 grammars. 183 AST refactor operations. 30 codebase analyzers. 15 query operations. 8 porting operations. 10 pre-built agent skills. One native Rust binary. Built-in MCP server for Claude Code, Cursor, Codex, and OpenCode. Free for personal use. Your code stays on your machine.
act is a Model Context Protocol (MCP) server for AI coding agents. It exposes 183 AST-aware refactor operations (extract-function, rename, move-symbol, convert-to-dataclass, extract-trait, inline, and 177 more), 30 codebase analyzers (coupling, cycles, dead code, hotspots, module boundaries, migration readiness), 15 query operations (skeleton, references, callers, graph, control_flow), and 8 porting operations that drive end-to-end language migrations through a contract / inventory / ordering / manifest state machine. Plus 10 pre-built agent skills (architecture-audit, code-review, refactoring, migration-assessment, boundary-analysis, and more) that compose those operations into common engineering workflows. Across 163 grammars.
No tool like this has ever existed. Until act, an AI agent could chat about refactoring but couldn't actually do it — every change was a whole-file rewrite that lost comments, broke formatting, and had no undo. act gives the agent typed, AST-aware operations: extract a function from Python, rename a symbol across a Rust workspace, move a TypeScript module and update every import, port a C library to Rust through a contract / inventory / ordering / manifest state machine. With automatic checkpointing and instant undo on every operation.
The agent calls extract-function, rename, move-symbol, inline, convert-to-dataclass, extract-trait, add-type-hints, generate-init, organize-imports, and 174 more — across the entire codebase, AST-aware, with cross-file consistency. Automatic checkpoint on every operation. Instant undo if anything looks wrong.
The agent uses port_contract to anchor the source-to-target migration, port_inventory to enumerate every symbol that must move, port_order to resolve dependency ordering, and a port_manifest state machine (init / add / update / remove / note) to track progress step by step. Works between any two of the 163 supported grammars.
30 codebase analyzers: cohesion, coupling, cycles, chokepoints, hotspots, dead code, layers, seams, clusters, surface, fan balance, migration readiness, type completeness, and more. The agent gets a structural map of the repo before it touches a line.
architecture-audit, code-review, refactoring, code-navigation, code-generation, migration-assessment, boundary-analysis, change-impact, health-check, architectural-refactoring. Invoke with /skill-name in Claude Code, Cursor, Codex, or OpenCode.
One local binary, two transports: act mcp serve for stdio (Claude Code and other MCP clients) and act mcp http for HTTP+SSE (web clients, remote connections). Marketplace install blocks for every major agent host.
Query operations return the AST-derived slice the agent needs, not the whole file. references: 99.8% median savings. callers: 99.0%. graph: 95.2%. skeleton: 82.6%. The agent stays inside its context window on real codebases.
We ran act's query and analysis operations against a real monorepo and counted the tokens returned against the tokens an agent would have consumed reading whole files to answer the same question. 166 samples. 10 operations. One headline number.
| Operation | Median savings |
|---|---|
references | 99.8% |
callers | 99.0% |
get_type | 97.7% |
mutations | 95.4% |
graph | 95.2% |
skeleton | 82.6% |
interface | 82.0% |
control_flow | 77.5% |
symbols | 61.5% |
repo_outline | 57.3% |
* Unweighted mean of per-operation medians across a 166-sample benchmark on a real-world monorepo, tokenized with o200k_base (act 1.0.3, April 2026). Per-operation medians are reported against the token cost of reading whole files to serve the same query. Actual results will vary with repo size, query target, and language — small repos and short files erode the savings, and in edge cases (e.g. a one-file project where repo_outline is longer than the file itself) can invert them.
Free forever for personal use. See the savings yourself.
All prices USD. 7-day free trial, all features.
C/C++ → Rust. COBOL → Java. Ruby → Elixir. PHP → TypeScript. Python 2 → Python 3. End-to-end migrations aren't a per-seat purchase. Enterprise unlocks the full porting toolkit and the migration analyzers.
Language migrations don't fail at the syntax layer. They fail at five predictable junctures — picking the wrong file to port first, porting in the wrong dependency order, silently losing behavior the source handled, losing track of what's done and why, and failing to answer "how much is left." Enterprise is built for those five points.
Most migrations stall on the first decision: which module to port first. Pick wrong — high coupling, deep dependencies, untyped boundaries — and you're rewriting your rewrite in week three.
act assesses the whole codebase before the first port: readiness scores per file, natural service boundaries, API surface width, type-completeness gaps, orphan types, dead code, and coupling hotspots. The team starts with the files that are actually safe to start with.
Port a module before its dependencies and the result is a stub. Port them out of order across a five-hundred-file codebase and every leaf gets re-touched.
act recommends the next file from the un-ported set, leaves-first and dependency-aware. Ports land in the order the build actually wants — not the order of whoever opened the file.
The new code compiles. The tests pass. Six months in, production reveals the rewrite quietly dropped a guard clause, an error path, or a resource cleanup the source did correctly.
act extracts the source file's behavioral contract before the port — guard clauses, error paths, resource patterns, complexity, edge-case handling. The target has to satisfy that contract. Drift surfaces in review, not in production.
Six months in, no one on the team can tell you what's ported, what's stubbed, what's skipped, or why a decision was made the way it was. The migration becomes archaeology.
act keeps a persistent record of the migration: per-file status, symbol-level progress, and the notes that explain every decision while the context is still fresh. New contributors pick up where the last one stopped.
"Are we thirty percent done or seventy?" No one can answer it without re-scanning the source. Project plans drift; engineering trust erodes.
act answers the percent-complete question on demand: completed files, partial files, stubbed files, and target-side drift. Status is a command away, not a rumor.
Agents have crossed from dev-time chat into production workloads. They ship code, refactor systems, drive migrations — at scale, around the clock, inside customer environments. act is the language-aware engine those agents call, licensed for the way fleets actually deploy.
Sized to how you actually run agents — concurrency, environments, tenants, regions — not to how many laptops are on your network.
Bundle act into your agent platform, sandbox, or runtime. Your customers inherit the toolset without ever touching a license server.
Every operation checkpointed, instantly reversible. Your code stays on the box — no telemetry, no upload. Built for the agent that runs without a human watching.
One native Rust binary. No dependencies. No supply chain risk. No data exfiltration. Marketplace install for Claude Code, Cursor, Codex, and OpenCode.
Already have act on your PATH? Register the plugin with Claude Code:
Source, releases, and issue tracker on GitHub: github.com/act101-ai/act101 →
Code intelligence, semantic refactoring, architecture analysis, porting, and AI agent skills — broken out by tier so you can see exactly what Free, Pro, Teams, and Elite include. Migration and porting are covered separately under Enterprise.
Install free.
Run agentic code transformation on your codebase.
Watch the token count drop.
Free forever for personal use · $19/mo commercial.
Works with every local agentic coding platform.