act101

act101 is a groundbreaking developer tool that fundamentally redefines how AI coding agents interact with source code. Unlike conventional tools that rely on simple text generation or whole-file rewrites, act101 provides a sophisticated Model Context Protocol (MCP) server that exposes over 183 Abstract Syntax Tree (AST)-aware refactor operations, 30 codebase analyzers, 15 query operations, and 8 porting operations across an astonishing 163 programming languages. This means AI agents can now perform precise, language-aware code transformations such as extracting functions, renaming symbols across entire workspaces, moving modules with automatic import updates, and porting entire codebases from one language to another (e.g., C to Rust, Ruby to Elixir, COBOL to Java). Built as a single native Rust binary with no plugin runtime, no package graph, and no supply-chain attack surface, act101 prioritizes security and performance. Your code remains entirely on your machine with no telemetry, no indexing, and no caching. It integrates seamlessly with Claude Code, Cursor, Codex, and OpenCode, making it an indispensable asset for developers, engineering teams, and AI researchers who demand reliable, undoable, and context-aware code manipulation. act101 is free for personal use, democratizing access to enterprise-grade code refactoring and migration capabilities.

183 AST-Aware Refactor Operations

act101 provides a comprehensive suite of 183 typed, AST-aware refactor operations that go far beyond simple text replacement. 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 understands the syntactic and semantic structure of the code, preserving comments, formatting, and cross-file consistency. Automatic checkpointing on every operation and instant undo functionality ensure that agents can experiment fearlessly without risking codebase integrity.

Cross-Language Porting State Machine

The porting feature is driven by a sophisticated state machine comprising four key operations: port_contract (to anchor source-to-target migration), port_inventory (to enumerate every symbol that must move), port_order (to resolve dependency ordering), and port_manifest (a state machine with init/add/update/remove/note states to track progress). This structured approach enables end-to-end language migrations between any two of the 163 supported grammars, such as porting C to Rust, Ruby to Elixir, or COBOL to Java, with clear traceability and rollback capabilities.

30 Codebase Analyzers for Structural Insight

act101 equips AI agents with 30 powerful codebase analyzers that provide deep structural understanding before any changes are made. These analyzers assess cohesion, coupling, cycles, chokepoints, hotspots, dead code, layers, seams, clusters, surface area, fan balance, migration readiness, type completeness, and more. This allows agents to generate a comprehensive structural map of the repository, identifying problem areas, dependencies, and architectural patterns, which is critical for informed refactoring and migration decisions.

10 Pre-Built Agent Skills for Common Workflows

act101 includes 10 pre-built agent skills that compose its atomic operations into high-level 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. Invoked with a simple /skill-name command in Claude Code, Cursor, or other MCP clients, these skills automate complex, multi-step tasks, dramatically reducing the cognitive load on developers and enabling rapid iteration.

Refactoring a Large Python Monolith into Modular Components

A development team working on a legacy Python monolith can use act101 to systematically extract functions, rename symbols, and move modules across the codebase. The agent can analyze coupling and cycles, then apply extract-function and move-symbol operations with cross-file consistency. Automatic checkpointing allows the team to undo any change instantly, while the architecture-audit skill provides a structural map of the refactored system, ensuring a clean, maintainable modular architecture emerges.

Porting a Critical C Library to Rust for Memory Safety

An organization with a critical C library that needs memory safety guarantees can leverage act101's porting state machine. The agent first uses port_contract to define the migration scope, then port_inventory to enumerate every function, struct, and macro. Using port_order, it resolves dependency ordering and then systematically translates each component using port_manifest. The result is a Rust equivalent that preserves the original logic while benefiting from Rust's ownership model and zero-cost abstractions, all with full traceability.

Performing a Codebase Health Check Before a Major Release

Before a major release, a team can invoke the health-check agent skill to analyze the entire codebase. act101's 30 analyzers assess dead code, hotspots, fan balance, and migration readiness. The agent produces a detailed report highlighting areas of technical debt, high-risk modules, and potential refactoring targets. This data-driven approach allows the team to prioritize fixes, reduce risk, and ensure the release is built on a solid foundation, all without manual code review.

Migrating a Ruby on Rails Application to Elixir/Phoenix

A startup looking to scale their Ruby on Rails application can use act101 to port the codebase to Elixir and Phoenix. The agent uses the porting state machine to map Ruby models, controllers, and views to their Elixir equivalents. The migration-assessment skill identifies compatibility issues and migration readiness. The agent then systematically converts Ruby idioms to Elixir patterns, updating dependencies and configurations. This structured migration reduces downtime and ensures business logic is preserved accurately.

How does act101 ensure code safety during refactoring and porting?

act101 implements automatic checkpointing on every AST-aware operation, creating a snapshot of the codebase state before any change is made. If an operation produces unintended results, the agent can instantly undo the change, reverting to the previous checkpoint. This is far more reliable than whole-file rewrites, which often lose comments, break formatting, and lack undo capabilities. Additionally, all operations are performed locally on your machine with no telemetry, ensuring your code never leaves your control.

What programming languages does act101 support?

act101 supports an industry-leading 163 programming languages through its built-in grammars. This includes mainstream languages like Python, Rust, TypeScript, Go, Java, C, C++, Ruby, Elixir, and COBOL, as well as many niche and legacy languages. The grammars are compiled into a single native Rust binary, meaning no external dependencies or plugin runtimes are required. This extensive coverage makes act101 suitable for polyglot codebases and legacy system migrations.

How does act101 integrate with existing AI coding tools?

act101 is built as a Model Context Protocol (MCP) server, making it natively compatible with Claude Code, Cursor, Codex, and OpenCode. Integration is straightforward: you configure the MCP server endpoint in your AI coding tool, and the agent can then call act101's operations directly. The tool also provides 10 pre-built agent skills that can be invoked with a simple /skill-name command, abstracting complex workflows into single instructions. This seamless integration allows developers to enhance their existing AI workflows without changing their toolchain.

Is act101 free to use, and what are the licensing terms?

act101 is free for personal use, allowing individual developers to leverage its full capabilities without cost. For commercial or enterprise use, a paid license is required. The licensing model is designed to be straightforward: the software checks for a valid license key on startup, which may contact act101's servers for verification, but no code telemetry is collected. This ensures that while license compliance is enforced, your code and data remain private and secure on your machine.

act101 offers a free tier for personal use with full access to all 163 grammars, 183 refactor operations, 30 analyzers, 8 porting operations, and 10 pre-built agent skills. For commercial, team, or enterprise usage, paid licensing is available. Specific pricing for commercial plans is not publicly listed; interested organizations should contact act101 directly or visit their pricing page for detailed information on tiered plans, volume discounts, and enterprise support options. The tool is distributed as a single native Rust binary, and license verification may contact act101's servers, but no code telemetry is collected.