act101

act101 is a revolutionary Model Context Protocol (MCP) server that fundamentally transforms how AI coding agents interact with your codebase. For the first time, an AI agent can actually refactor and port code across 163 languages with precision and safety, rather than just chatting about it or performing clumsy whole-file rewrites. This powerful native Rust binary exposes 183 AST-aware refactor operations, 30 codebase analyzers, 15 query operations, 8 porting operations, and 10 pre-built agent skills directly to Claude Code, Cursor, Codex, and OpenCode. Whether you are a solo developer modernizing a legacy Python project, a team migrating a critical C library to Rust, or an enterprise architect assessing a multi-language codebase for technical debt, act101 empowers your AI agent to execute real, structural code transformations. Every operation is AST-aware, meaning comments stay intact, formatting is preserved, and changes are consistent across files. Automatic checkpointing and instant undo give you complete control and confidence. Your code never leaves your machine, and there is no indexing, caching, or cold start. act101 is free for personal use, making professional-grade AI-assisted refactoring and porting accessible to every developer.

183 AST Refactor Operations for AI Agents

act101 provides an unprecedented library of 183 typed, AST-aware refactor operations that your AI agent can call directly. These operations include extract-function, rename-symbol, move-symbol, inline-variable, convert-to-dataclass, extract-trait, add-type-hints, organize-imports, and 176 more sophisticated transformations. Unlike traditional file-based approaches that rewrite entire files and destroy comments and formatting, each operation is a surgical, language-aware transformation that maintains cross-file consistency. The agent can refactor across your entire codebase, applying changes that respect the abstract syntax tree of each language. Automatic checkpointing occurs on every operation, and instant undo is available if the result does not meet your expectations. This feature transforms your AI agent from a code suggestion tool into a genuine code transformation engine.

8 Cross-Language Porting Operations

act101 introduces a revolutionary state-machine approach to code porting that makes cross-language migration a structured, agent-executable process. The porting system uses four key operations: port_contract to anchor the source-to-target migration with explicit guarantees, port_inventory to enumerate every symbol and construct that must be moved, port_order to resolve dependency ordering between components, and a port_manifest state machine with init, add, update, remove, and note states to track progress step by step. This system works between any two of the 163 supported grammars, enabling your agent to port C to Rust, Ruby to Elixir, COBOL to Java, or any other combination. The structured approach ensures no symbol is forgotten, dependencies are respected, and the migration is fully traceable and reversible.

30 Codebase Analyzers for Deep Structural Insight

Before your agent touches a single line of code, act101 provides a comprehensive structural map of your entire codebase through 30 specialized analyzers. These analyzers measure cohesion, coupling, cycles, chokepoints, hotspots, dead code, layers, seams, clusters, surface area, fan balance, migration readiness, type completeness, and more. The agent receives a detailed, quantified understanding of your codebase's architecture, technical debt, and migration readiness. This analysis powers informed decision-making: the agent knows exactly which modules are tightly coupled, where dead code lurks, which components are hotspots for change, and how ready each part of the system is for migration. This feature transforms guesswork into data-driven code transformation.

10 Pre-Built Agent Skills for Common Workflows

act101 ships with 10 pre-built agent skills that compose its operations into powerful, ready-to-use 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 solves a specific engineering problem. For example, the code-review skill analyzes coupling, cycles, and hotspots to produce a structured review, while the migration-assessment skill evaluates migration readiness across all 30 analyzers. You invoke these skills with a simple /skill-name command in Claude Code, Cursor, or other MCP-aware clients, instantly accessing complex multi-step workflows without manual orchestration.

Modernizing a Legacy Python Monolith

A developer inherits a sprawling Python monolith with thousands of lines of tightly coupled code. Using act101, they direct their AI agent to run the architecture-audit skill, which immediately identifies hotspots of high coupling, dead functions, and cyclic dependencies. The agent then systematically applies refactor operations: extract-function to break down massive functions, extract-trait to separate concerns, and move-symbol to reorganize modules. Each operation is checkpointed, and the developer can instantly undo any change that introduces issues. Within hours, the monolith is transformed into a well-structured, maintainable codebase with clear module boundaries and reduced technical debt.

Porting a Critical C Library to Rust

A systems team needs to port a performance-critical C library to Rust for memory safety and modern tooling. With act101, the agent initiates the porting workflow by calling port_contract to define the migration scope. It then uses port_inventory to enumerate every C function, struct, and macro that must be ported. The port_order operation resolves the dependency graph, ensuring that foundational types are ported before the functions that use them. The port_manifest state machine tracks every step, from init through add, update, and remove. The agent systematically translates each C construct to idiomatic Rust, preserving the original logic while leveraging Rust's safety guarantees. The entire migration is traceable, reversible, and completed in a fraction of the time manual porting would require.

Assessing Migration Readiness for a Multi-Language Codebase

An enterprise architect needs to evaluate the feasibility of migrating a codebase consisting of COBOL, Java, and Python components to a modern stack. Using act101's migration-assessment skill, the agent runs all 30 analyzers across the entire codebase. It produces a detailed report showing which modules have high migration readiness, which are tightly coupled and risky to move, and where dead code can be eliminated before migration. The agent identifies seams in the architecture where the system can be broken into independently portable components. This analysis empowers the architect to make data-driven decisions about migration strategy, resource allocation, and risk mitigation, turning a daunting multi-language migration into a structured, manageable project.

Performing Continuous Code Review in CI/CD

A development team integrates act101 into their CI/CD pipeline to perform automated, AI-driven code reviews on every pull request. When a PR is submitted, the agent runs the code-review skill, which analyzes the changed files for coupling increases, new cycles, dead code introduction, and boundary violations. The agent also runs the change-impact skill to assess how the changes affect the broader system. The review output includes specific refactoring suggestions with exact operation calls that can be applied. Developers receive actionable, AST-precise feedback that goes far beyond simple linting, catching architectural issues before they become entrenched. This continuous review process maintains code quality at scale, even as the team grows and the codebase evolves.

act101 is free for personal use, giving individual developers full access to all features including 183 AST refactor operations, 30 codebase analyzers, 8 porting operations, 15 query operations, and 10 pre-built agent skills. For teams and organizations requiring advanced features, priority support, or commercial licensing, please see our pricing page for available plans. The free personal tier includes all core functionality with no limitations on the number of operations or languages you can use. Your code remains on your machine regardless of your pricing tier.

How does act101 differ from using an AI agent with whole-file rewriting?

act101 fundamentally changes how AI agents modify code by using AST-aware operations instead of whole-file rewrites. Whole-file rewriting is destructive: it loses comments, breaks formatting, and provides no undo capability. In contrast, act101's operations are surgical transformations that preserve all comments and formatting while maintaining cross-file consistency. Each operation creates an automatic checkpoint, and you can instantly undo any change. The agent works with the code's actual structure, not just its text, enabling precise transformations like renaming a symbol across an entire workspace or extracting a function while updating all callers. This approach uses approximately 85% fewer tokens than file-based operations, making it more efficient and less prone to hallucination.

Is my code sent to external servers when using act101?

No. act101 is designed with privacy as a core principle. Your code stays entirely on your machine. The tool is a native Rust binary that runs locally, with no indexing, no caching, and no telemetry that sends your code to external servers. The only external communication is license verification, which may contact our servers to validate your license key. There is no plugin runtime, no package graph, and no supply-chain attack surface. This makes act101 suitable for even the most security-conscious development environments, including those with strict data residency requirements.

What languages does act101 support for refactoring and porting?

act101 supports 163 grammars in a single binary, making it one of the most comprehensive language-aware tools available. This includes all major languages such as Python, Rust, TypeScript, JavaScript, Go, Java, C, C++, Ruby, Elixir, COBOL, Swift, Kotlin, and many more. The 183 AST refactor operations work across all supported languages, and the 8 porting operations enable migration between any two supported grammars. The 30 codebase analyzers also work across the full language set, providing consistent structural analysis regardless of the languages in your codebase. The single binary includes all grammars, so there is no need to download language-specific plugins or runtimes.

How do I integrate act101 with my existing AI coding tools?

act101 is designed as a Model Context Protocol (MCP) server, which means it integrates seamlessly with any MCP-aware client. This includes Claude Code, Cursor, Windsurf, Codex, OpenCode, and other tools that support the MCP standard. Integration is straightforward: you install the act101 binary, configure it as an MCP server in your tool of choice, and the AI agent immediately gains access to all 183 refactor operations, 30 analyzers, 8 porting operations, 15 query operations, and 10 pre-built skills. You can invoke skills with /skill-name commands directly in your chat interface. The built-in MCP server handles all communication, so you do not need to write any glue code or manage API keys.