act101

act101 is a groundbreaking developer tool that represents the first evolution of AI-assisted code manipulation. It is a Model Context Protocol (MCP) server that empowers AI coding agents to perform genuine, language-aware code refactoring and porting across an unprecedented 163 programming languages. Unlike previous tools that could only offer chat-based suggestions or perform crude whole-file rewrites, act101 provides agents with a comprehensive toolkit of 183 Abstract Syntax Tree (AST) refactor operations, 30 codebase analyzers, 15 query operations, and 8 dedicated porting operations. This tool is designed for developers using AI coding assistants like Claude Code, Cursor, Codex, and OpenCode, enabling them to delegate complex, structural code transformations to an AI agent with confidence. The core value proposition is that it moves AI from being a passive code reviewer to an active, reliable code transformer. Built as a single, native Rust binary, act101 is secure, fast, and requires no indexing or caching, ensuring results are always current. It is free for personal use, making advanced AI-driven code evolution accessible to individual developers and small teams looking to modernize, migrate, or simply improve their codebases without the risk of losing formatting, comments, or the ability to undo changes. This tool marks a significant stage in the growth of AI coding, shifting from simple generation to intelligent, structural evolution.

163 Grammars in One Binary

act101 ships with a single, native Rust binary that contains parsers for 163 programming languages. This eliminates the need for multiple plugins, package dependencies, or complex runtime environments. Whether you are working with Python, Rust, TypeScript, Go, C, Ruby, Elixir, or even legacy languages like COBOL, act101 can parse and understand the code's structure instantly. This comprehensive language support is a foundational feature that enables all other operations, from refactoring to porting, to work seamlessly across a vast ecosystem of languages, representing a major evolutionary leap in tooling for polyglot developers.

183 AST Refactor Operations

The tool exposes a rich library of 183 typed, AST-aware refactor operations that agents can call. These include fundamental operations like extract-function, rename-symbol, and inline-variable, as well as advanced transformations like convert-to-dataclass, extract-trait, and move-symbol across files. Each operation is safe and precise, operating on the code's structure rather than its text. This means comments are preserved, formatting is maintained, and cross-file consistency is guaranteed. Every operation creates an automatic checkpoint, allowing for instant undo, which is a critical safety net for iterative, agent-driven development workflows.

30 Codebase Analyzers

act101 includes 30 built-in codebase analyzers that provide deep structural insights. Agents can analyze coupling between modules, detect cyclic dependencies, find dead code, identify chokepoints and hotspots, assess migration readiness, and evaluate type completeness. These analyzers give the AI agent a structural map of the repository before it makes any changes. This capability transforms the agent from a blind code writer into an informed architect, capable of understanding the health and dependencies of a codebase and making decisions that improve its overall quality, representing a growth stage where AI can truly audit and improve software architecture.

8 Porting Operations with a State Machine

For cross-language migrations, act101 provides 8 dedicated porting operations that drive an end-to-end state machine. The process begins with port_contract to anchor the migration goals, followed by port_inventory to enumerate every symbol that must move, and port_order to resolve the correct dependency ordering. A port_manifest state machine (with states like init, add, update, remove, note) tracks progress step by step, ensuring a systematic and reliable migration. This feature allows an agent to port a C library to Rust or a Ruby application to Elixir with a clear, auditable plan, marking a significant evolution from manual, error-prone rewrites to structured, automated migration.

Modernizing a Legacy Python Codebase

A development team is tasked with modernizing a large, monolithic Python application. Using act101, an AI agent can be instructed to perform a series of targeted refactors. The agent can first run the architecture-audit skill to analyze the codebase for coupling and cycles. Then, using operations like extract-function, rename-symbol, and convert-to-dataclass, it can systematically refactor the code into a more modular and maintainable structure. The agent can also use the change-impact analyzer to understand the ripple effects of each change, and the built-in checkpointing ensures that any undesirable transformation can be instantly undone, allowing for safe, iterative modernization.

Porting a C Library to Rust for Safety

A company wants to port a critical C library to Rust to gain memory safety and performance. Instead of a manual, months-long rewrite, a developer can use act101 with an AI agent. The agent initiates the process by calling port_contract to define the scope, then port_inventory to list all C functions and data structures. Using port_order, it determines the correct sequence for translation. The agent then iteratively calls port_manifest operations to add the corresponding Rust code, translating C patterns to safe Rust idioms. The 163-grammar support ensures the agent understands both languages at a deep, structural level, making the porting process systematic and reliable.

Performing a Cross-Workspace Refactoring in TypeScript

A large frontend project in TypeScript has grown organically, resulting in tangled dependencies and poorly named modules. An engineer uses act101 and Claude Code to clean up the workspace. The agent uses the skeleton query to understand the project structure and the references query to find all usages of a poorly named symbol. It then calls rename-symbol across the entire workspace, updating every import and reference automatically. Next, it uses move-symbol to relocate a module to a better directory, and the agent automatically updates all import paths. This cross-file, AST-aware refactoring is a core strength of act101, turning a tedious manual task into a single, high-level command.

Analyzing and Decoupling a Ruby on Rails Monolith

A team wants to extract a microservice from a Ruby on Rails monolith. Using act101, an AI agent first runs the boundary-analysis and coupling analyzers to identify the natural seams in the codebase. The agent can then visualize the dependency graph using the graph query operation. Based on this analysis, the agent can use the extract-class and move-symbol refactor operations to begin isolating the domain logic into its own module, ready for extraction. This use case demonstrates how act101 enables a data-driven, architectural evolution of a codebase, moving from a monolithic structure to a more modular, service-oriented one.

Is act101 safe to use with my production code?

Yes, act101 is designed with safety as a core principle. It runs entirely on your local machine, and your code never leaves your computer. There is no telemetry, and license verification is the only time it may contact our servers. Every refactor and porting operation creates an automatic checkpoint, enabling instant undo if the result is not as expected. The tool operates on the AST, not raw text, which preserves formatting and comments, reducing the risk of introducing errors.

What AI coding assistants are compatible with act101?

act101 is built as a Model Context Protocol (MCP) server, making it compatible with any MCP-aware client. This includes popular tools like Claude Code, Cursor, Codex, and OpenCode. You can also use it with Windsurf or any other MCP-compatible interface. The integration is seamless; once the MCP server is running, your AI agent can directly call the 183 refactor operations, 30 analyzers, and 8 porting operations as if they were native capabilities.

How does act101 compare to simple whole-file rewrites by an AI?

act101 represents a significant evolution over simple whole-file rewrites. A whole-file rewrite often loses comments, breaks formatting, and has no concept of undo. In contrast, act101 performs typed, AST-aware operations. For example, renaming a symbol will update every reference across the entire codebase, not just in one file. Extracting a function will correctly handle variable scope and return values. Every operation is precise, safe, and reversible, providing a level of control and reliability that simple text generation cannot match.

What is the performance impact of using act101 on a large codebase?

act101 is built as a single, native Rust binary, which is extremely fast and efficient. It requires no indexing or caching, meaning there is no cold start or stale data. It parses code on demand, and the operations are highly optimized. The AST-based approach is also more token-efficient for the AI agent, using approximately 85% fewer tokens than file-based operations. This leads to faster responses and lower costs when using API-based AI assistants. The tool is designed to handle large codebases with minimal performance overhead.