act101

act101 is a revolutionary developer tool that fundamentally changes how AI coding agents interact with source code. It is the first and only dev tool that enables AI agents to perform actual, language-aware code refactoring and porting across an unprecedented 163 programming languages. At its core, act101 is a Model Context Protocol (MCP) server that exposes a rich set of 183 Abstract Syntax Tree (AST) refactor operations, 30 codebase analyzers, 15 query operations, and 8 porting operations to AI agents like Claude Code, Cursor, Codex, and OpenCode. The primary challenge act101 solves is the historical inability of AI agents to make precise, context-aware code changes. Previously, agents could only suggest or rewrite entire files, often breaking formatting, losing comments, and providing no undo capability. act101 changes this by giving agents typed, AST-aware operations that maintain cross-file consistency, preserve code structure, and offer automatic checkpointing with instant undo. It is built as a single native Rust binary with no external dependencies, no indexing, and no caching, ensuring that code remains on the user's machine with zero telemetry. act101 is designed for developers and engineering teams who need to automate complex code transformations, migrate legacy codebases, or perform large-scale refactoring with the precision and reliability of a human expert. It is free for personal use and offers a robust feature set that includes pre-built agent skills for common engineering workflows such as architecture auditing, code review, and migration assessment.

183 AST-Aware Refactor Operations

act101 provides an extensive library of 183 typed, Abstract Syntax Tree (AST) aware refactoring operations that AI agents can call directly. These operations include fundamental transformations like extract-function, rename, move-symbol, inline, and convert-to-dataclass, as well as advanced operations like extract-trait, add-type-hints, generate-init, and organize-imports. Unlike traditional file-based rewrites, each operation understands the syntactic structure of the code, ensuring that changes are precise, maintain cross-file consistency (e.g., updating all imports when a symbol is moved), and preserve comments and formatting. Every operation automatically creates a checkpoint, allowing the agent or developer to instantly undo any change that looks incorrect. This feature transforms AI agents from passive code suggesters into active, reliable code manipulators capable of handling complex refactoring tasks across entire codebases.

Multi-Language Porting State Machine

act101 introduces a sophisticated state machine for porting code between any two of the 163 supported grammars, enabling true cross-language migration. The porting process is driven by four core operations: port_contract to anchor the source-to-target migration goals, port_inventory to enumerate every symbol that must be moved, port_order to resolve dependency ordering constraints, and a port_manifest state machine (with states: init, add, update, remove, note) to track progress step by step. This structured approach allows AI agents to methodically port code from languages like C to Rust, Ruby to Elixir, or COBOL to Java, ensuring that no symbol is missed and dependencies are correctly resolved. The state machine provides a clear, auditable trail of the migration process, making it ideal for large-scale legacy system modernization where precision and traceability are critical.

30 Codebase Analyzers for Structural Insight

act101 equips AI agents with 30 built-in codebase analyzers that provide deep structural insight into a codebase before any changes are made. These analyzers cover critical software engineering concerns including cohesion, coupling, cycles, chokepoints, hotspots, dead code detection, layers, seams, clusters, surface area, fan balance, migration readiness, and type completeness. Each analyzer produces a structured map of the repository, revealing architectural issues, dependencies, and areas of high complexity. For example, the coupling analyzer identifies tightly coupled modules that could hinder refactoring, while the dead code analyzer finds unused functions and variables. This feature empowers AI agents to make informed decisions about where to apply refactoring operations, prioritize technical debt reduction, and assess the feasibility of migration projects before investing effort.

Pre-Built Agent Skills for Engineering Workflows

act101 includes 10 pre-built agent skills that compose its low-level operations into common, high-value engineering workflows. These skills include architecture-audit, code-review, refactoring, code-navigation, code-generation, migration-assessment, boundary-analysis, change-impact, health-check, and architectural-refactoring. Each skill is a curated sequence of operations that an AI agent can invoke with a simple command like /skill-name in Claude Code, Cursor, or other MCP-aware clients. For example, the architecture-audit skill runs multiple analyzers and query operations to produce a comprehensive report of the codebase's structure and weaknesses. The migration-assessment skill evaluates a codebase's readiness for porting by analyzing symbol inventory, dependencies, and potential challenges. These skills dramatically reduce the cognitive load on developers by packaging expert-level analysis and transformation logic into repeatable, agent-executable routines.

Large-Scale Codebase Refactoring

Engineering teams maintaining large, monolithic codebases often face the daunting task of refactoring to improve modularity, reduce technical debt, or adopt new design patterns. act101 enables AI agents to perform precise, AST-aware refactoring operations across hundreds of files simultaneously, such as extracting functions from deeply nested methods, renaming symbols consistently throughout the codebase, or converting classes to dataclasses. The automatic checkpointing and instant undo features ensure that mistakes can be quickly reversed without manual intervention. This use case is particularly valuable for teams migrating from legacy patterns to modern architectures, as the agent can systematically apply transformations while preserving code semantics and avoiding the breakage common with whole-file rewrites.

Cross-Language Code Migration and Porting

Organizations modernizing legacy systems often need to port code from older languages like COBOL, C, or Ruby to modern alternatives like Java, Rust, or Elixir. act101's state machine-driven porting operations provide a structured, auditable approach to this complex task. An AI agent can use port_contract to define the scope of the migration, port_inventory to catalog every function, variable, and type that must be translated, port_order to determine the correct sequence of translations based on dependencies, and the port_manifest to track each step. This use case is ideal for financial institutions, government agencies, or enterprises with large COBOL or C codebases that need to be modernized while maintaining business continuity and regulatory compliance.

Automated Code Review and Architecture Auditing

Development teams can leverage act101's 30 codebase analyzers and pre-built skills to automate code review and architecture auditing processes. When a developer submits a pull request, an AI agent can run the code-review skill, which analyzes the changes for coupling issues, dead code, hotspots, and boundary violations. Similarly, the architecture-audit skill can be run periodically to generate a structural map of the entire codebase, highlighting areas with high cyclomatic complexity, circular dependencies, or migration bottlenecks. This use case helps teams identify and address architectural debt early, enforce coding standards, and maintain a healthy codebase without requiring manual, time-consuming reviews by senior engineers.

Technical Debt Assessment and Prioritization

Organizations struggling with accumulating technical debt can use act101 to systematically assess and prioritize remediation efforts. An AI agent can run the health-check skill across the codebase to generate a comprehensive report on code quality metrics, including cohesion, coupling, dead code, and type completeness. The migration-assessment skill can evaluate specific modules for their readiness for refactoring or porting, identifying which areas offer the highest return on investment for improvement. This use case enables engineering managers to make data-driven decisions about where to allocate refactoring resources, track progress over time, and demonstrate the impact of technical debt reduction initiatives to stakeholders.

How does act101 differ from using an AI agent to rewrite entire files?

act101 operates on the Abstract Syntax Tree (AST) of the code, meaning it understands the syntactic structure of the language. This allows it to make precise, targeted changes like extracting a single function or renaming a symbol across multiple files, while preserving comments, formatting, and cross-file consistency. In contrast, whole-file rewrites often break formatting, lose comments, and have no undo capability. act101 also provides automatic checkpointing and instant undo on every operation, giving developers full control and safety.

Is act101 safe to use with proprietary or sensitive code?

Yes, act101 is designed with security and privacy as a priority. It runs as a native Rust binary on your own machine with no indexing, no caching, and no telemetry. Your code never leaves your machine. The only external communication is for license verification, which may contact our servers. There is no plugin runtime, no package graph, and no supply-chain attack surface, making it suitable for use with proprietary codebases in regulated industries.

Which AI coding agents and IDEs 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 AI coding agents like Claude Code, Cursor, Codex, and OpenCode. It also works with Windsurf and any other tool that supports the MCP standard. The built-in MCP server means there is no need for additional configuration or plugins to connect with these tools.

How many programming languages does act101 support, and what are the most notable ones?

act101 supports 163 programming languages through its grammar definitions. This includes all major languages such as Python, JavaScript, TypeScript, Rust, Go, Java, C, C++, Ruby, Elixir, and COBOL. The comprehensive language support means that act101 can be used for both refactoring within a single language and porting between any two supported languages, making it an extremely versatile tool for polyglot codebases and migration projects.

act101 is free for personal use. For commercial or team use, please see our pricing page for available plans and licensing options.