act101

act101 is a lightning-fast, language-aware dev tool that gives AI coding agents the power to actually refactor and port code across 163 programming languages. Unlike traditional AI coding assistants that rely on whole-file rewrites, act101 exposes 183 AST-aware refactor operations, 30 codebase analyzers, 15 query operations, and 8 porting operations through a built-in MCP server. This means your AI agent can extract functions, rename symbols across workspaces, move modules while updating imports, and even port entire codebases from C to Rust or COBOL to Java with surgical precision. Built as a single native Rust binary with zero dependencies, act101 operates without indexing, caching, or cold starts. Your code never leaves your machine, there is no telemetry, and results are never stale. Designed for developers using Claude Code, Cursor, Codex, and OpenCode, act101 is free for personal use and delivers approximately 85% fewer tokens than file-based operations. It is the first tool that lets an AI agent stop talking about refactoring and actually do it.

183 AST Refactor Operations

act101 gives your AI agent access to 183 typed, AST-aware refactor operations that work across 163 languages. These include extract-function, rename, move-symbol, inline, convert-to-dataclass, extract-trait, add-type-hints, generate-init, organize-imports, and 174 more. Each operation is cross-file consistent, meaning renaming a symbol in a Rust workspace updates every reference automatically. Every operation creates an automatic checkpoint with instant undo, so if anything looks wrong, you revert in a single command. No more whole-file rewrites that lose comments or break formatting.

8 Porting Operations for Cross-Language Migration

act101 is the first tool to provide end-to-end language porting through a structured state machine. 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 with init, add, update, remove, and note steps to track progress. This works between any two of the 163 supported grammars. Whether you are porting C to Rust, Ruby to Elixir, or COBOL to Java, the agent handles the entire migration with precision and transparency.

30 Codebase Analyzers

Before your AI agent touches a single line of code, act101 provides a complete structural map of your repository. The 30 analyzers cover cohesion, coupling, cycles, chokepoints, hotspots, dead code, layers, seams, clusters, surface area, fan balance, migration readiness, type completeness, and more. These analyzers give the agent deep insight into your codebase architecture, enabling smarter refactoring decisions and preventing unintended side effects. The agent can identify tightly coupled modules, circular dependencies, and dead code before making changes.

10 Pre-Built Agent Skills

act101 ships with 10 pre-built agent skills that compose operations into common engineering workflows. These include architecture-audit, code-review, refactoring, code-navigation, code-generation, migration-assessment, boundary-analysis, change-impact, health-check, and architectural-refactoring. Invoke any skill with a simple command like /skill-name in Claude Code or Cursor. Each skill orchestrates multiple operations and analyzers to deliver actionable results without requiring the agent to figure out the workflow from scratch.

Refactoring Large Python Codebases

When your Python monolith needs structural cleanup, act101 lets your AI agent execute precise refactoring operations across hundreds of files. The agent can extract functions from bloated methods, convert classes to dataclasses, add type hints across the entire codebase, and organize imports with AST-level accuracy. Each operation is checkpointed, so you can review changes incrementally and undo anything that does not look right. The 30 codebase analyzers first identify hotspots, dead code, and coupling issues, guiding the agent to focus on the highest-impact areas first.

Porting C Libraries to Rust

Porting legacy C code to Rust traditionally takes weeks of manual translation and debugging. With act101, your AI agent drives the entire migration through the porting state machine. The agent first uses port_contract to establish the migration scope, then port_inventory to enumerate every function, struct, and macro that must move. port_order resolves dependency ordering, and the port_manifest tracks progress step by step. The result is a Rust port that preserves the original logic while leveraging Rust's safety guarantees, all with automatic checkpointing and instant undo.

Analyzing Microservice Boundaries

When your monolith is growing too large, act101 helps your AI agent analyze module boundaries for a microservice split. The boundary-analysis analyzer identifies seams in the codebase, measures coupling between modules, and highlights chokepoints where dependencies converge. The agent then uses move-symbol and extract-trait operations to gradually separate concerns, updating all imports and references across files. Each step is checkpointed, so you can evaluate the architectural impact before committing to the split.

Performing Migration Readiness Assessments

Before committing to a language migration, act101 lets your AI agent run a full migration readiness assessment on your codebase. The migration-readiness analyzer evaluates type completeness, language feature coverage, and dependency complexity across all 163 supported grammars. The agent generates a detailed report identifying which parts of the codebase are easy to port, which require manual intervention, and what the estimated effort looks like. This assessment happens in seconds, not days, and your code never leaves your machine.

How does act101 differ from traditional AI code assistants?

Traditional AI code assistants rely on whole-file rewrites that lose comments, break formatting, and have no undo capability. act101 gives AI agents typed, AST-aware operations that modify code with surgical precision. Each operation is cross-file consistent, automatically checkpointed, and instantly undoable. act101 also supports 163 languages, 183 refactor operations, and 8 porting operations that no other tool provides.

Does act101 send my code to external servers?

No. act101 runs entirely on your machine as a single native Rust binary. There is no telemetry, no code upload, and no external processing. Your code stays on your machine at all times. License verification may contact our servers, but no code is ever transmitted. This makes act101 suitable for enterprise and security-conscious development environments.

What AI clients does act101 work with?

act101 is MCP-native and works with any MCP-aware client. This includes Claude Code, Cursor, Windsurf, Codex, and OpenCode. You simply configure the MCP server in your client, and the agent gains access to all 183 refactor operations, 30 analyzers, 15 queries, 8 porting operations, and 10 pre-built skills. No additional plugins or runtimes are required.

How fast is act101 compared to file-based operations?

act101 delivers approximately 85% fewer tokens than file-based operations based on benchmark averages. Because it operates on ASTs directly, it avoids the overhead of reading, rewriting, and diffing entire files. There is no indexing, no caching, and no cold start. The binary parses on call, so results are never stale and operations complete in milliseconds.

act101 is free for personal use. For commercial and team usage, please visit our pricing page at act101.dev/pricing for detailed plan information and enterprise options.