act101

act101 is the first dev tool that actually lets an AI agent refactor and port code across 163 languages. Forget the hype about AI coding assistants that can only chat about refactoring but never actually do it. act101 is a native Rust binary that packs 163 grammars, 183 AST refactor operations, 30 codebase analyzers, and 8 porting operations into one blazingly fast, zero-bloat package. It works as a Model Context Protocol (MCP) server, so it plugs directly into Claude Code, Cursor, Codex, Windsurf, and OpenCode. The agent gets typed, AST-aware operations instead of guessing at whole-file rewrites that break formatting and lose comments. Every operation comes with automatic checkpointing and instant undo. Your code never leaves your machine. No indexing, no caching, no cold starts. No telemetry. No supply-chain attack surface. It is built for developers who are tired of AI tools that pretend to understand code but actually just smash text together. act101 is for the engineer who wants an AI agent that can extract a function from Python, rename a symbol across a Rust workspace, port a C library to Rust, or analyze coupling cycles in a TypeScript monorepo. It is free for personal use. This is the tool that finally makes AI agents useful for actual, production-grade code work.

183 AST Refactor Operations for AI Agents

act101 exposes 183 typed, AST-aware refactor operations that cover everything from basic moves to advanced structural changes. Extract-function, rename, move-symbol, inline, convert-to-dataclass, extract-trait, add-type-hints, organize-imports, and 174 more. These operations work across the entire codebase with cross-file consistency. The agent calls them directly, so every change is precise and reversible. No more whole-file rewrites that destroy formatting and lose comments. Each operation creates an automatic checkpoint, and the agent can undo instantly if anything looks wrong. This is the difference between an AI that chats about refactoring and an AI that actually refactors.

8 Porting Operations for Cross-Language Migration

Porting code between languages is the holy grail of dev tools, and act101 delivers it with a contract/inventory/ordering/manifest 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 operations to track progress step by step. It works between any two of the 163 supported grammars. Port C to Rust. Port Ruby to Elixir. Port COBOL to Java. The agent drives the entire migration with language-aware precision.

30 Codebase Analyzers for Structural Intelligence

act101 gives the agent 30 codebase analyzers that provide a structural map of the repo before it touches a single line. Cohesion, coupling, cycles, chokepoints, hotspots, dead code, layers, seams, clusters, surface, fan balance, migration readiness, type completeness, and more. The agent can analyze the entire codebase in seconds and use that intelligence to make better refactoring and porting decisions. This is not a simple linter. This is deep structural analysis that reveals the hidden architecture of your code. The agent knows where the chokepoints are, where the dead code lives, and where the coupling cycles will bite you.

10 Pre-Built Agent Skills for Common Workflows

act101 ships with 10 pre-built agent skills that compose the raw operations into common engineering workflows. Architecture-audit, code-review, refactoring, code-navigation, code-generation, migration-assessment, boundary-analysis, change-impact, health-check, and architectural-refactoring. Invoke any skill with /skill-name in Claude Code, Cursor, or any MCP-aware client. Each skill chains together multiple operations to accomplish a complex task. For example, the architecture-audit skill runs all 30 analyzers and produces a complete structural report. The migration-assessment skill runs port_contract, port_inventory, and port_order to evaluate the feasibility of a language migration before you commit to it.

Refactoring a Large Python Monorepo with Cross-File Consistency

A team maintains a sprawling Python monorepo with hundreds of modules and thousands of functions. They need to extract a core utility function into a separate module, rename it consistently across all callers, and add type hints. With act101, the agent calls extract-function, rename, and add-type-hints as typed AST operations. Every change is cross-file consistent. Every operation is checkpointed. If something breaks, the agent undoes instantly. The whole refactoring takes minutes instead of days, and the code stays clean and readable.

Porting a Legacy C Library to Rust with Full Migration Tracking

An engineering team has a critical C library that needs to be ported to Rust for safety and performance. The library has complex dependency chains and hundreds of symbols. act101 drives the migration with its porting state machine. The agent calls port_contract to define the migration scope, port_inventory to enumerate every symbol, port_order to resolve the dependency graph, and port_manifest to track progress. The agent ports each function and struct one by one, with language-aware translation. The result is a Rust library that preserves the original logic while adding memory safety and modern idioms.

Analyzing Coupling and Dead Code in a TypeScript Application

A frontend team is struggling with a TypeScript application that has grown unwieldy. They suspect high coupling and significant dead code, but they cannot prove it. act101 runs its 30 analyzers on the entire codebase. The coupling analyzer reveals tight dependencies between modules that should be independent. The dead code analyzer finds dozens of unused exports and components. The chokepoint analyzer identifies the modules that will break if anything changes. The team uses this intelligence to plan a targeted refactoring that reduces coupling by 40% and eliminates 15% of the codebase.

Performing a Migration Assessment Before Porting Ruby to Elixir

A startup wants to port their Ruby backend to Elixir for better concurrency and fault tolerance. Before committing to the migration, they need to know how difficult it will be. act101 runs the migration-assessment skill, which calls port_contract, port_inventory, and port_order. The agent produces a detailed report showing which Ruby patterns map cleanly to Elixir, which patterns will require significant rework, and the estimated dependency ordering. The team uses this report to decide whether to proceed with the migration or refactor the Ruby code first.

How does act101 differ from other AI coding tools?

act101 is fundamentally different because it operates on the Abstract Syntax Tree (AST) rather than on raw text. Other AI coding tools treat code as text and use whole-file rewrites that lose formatting, break comments, and have no undo. act101 gives the agent typed, AST-aware operations that preserve structure, maintain formatting, and provide instant undo through automatic checkpoints. It also packs 163 grammars into a single native Rust binary with no plugin runtime, no package graph, and no supply-chain attack surface. Your code stays on your machine with no telemetry.

Does act101 require an internet connection or cloud service?

No. act101 runs entirely on your machine as a native Rust binary. There is no cloud service, no indexing, no caching, and no cold start. The binary parses code on each call, so results are never stale. License verification may contact our servers, but your code never leaves your machine. There is no telemetry, no data collection, and no external dependencies. This is a local-first tool designed for security-conscious teams.

Which AI coding agents and IDEs does act101 support?

act101 works with any MCP-aware client, including Claude Code, Cursor, Codex, Windsurf, and OpenCode. It exposes its operations through a built-in MCP server that the agent connects to directly. You can also invoke the 10 pre-built agent skills using /skill-name in Claude Code or Cursor. The tool is designed to be agent-agnostic, so as new AI coding tools emerge, they can integrate with act101 as long as they support the MCP protocol.

Can act101 port code between any of the 163 languages?

Yes. The 8 porting operations work between any two of the 163 supported grammars. The agent uses a contract/inventory/ordering/manifest state machine to drive the migration step by step. This means you can port C to Rust, Ruby to Elixir, COBOL to Java, Python to TypeScript, or any other combination. The tool is language-aware at the AST level, so it understands the semantics of both the source and target languages, not just their syntax.

act101 is free for personal use. There is no cost for individual developers to use the tool on their own projects. For commercial or team use, see the pricing page on the act101 website. The free tier includes full access to all 163 grammars, all 183 refactor operations, all 30 analyzers, all 8 porting operations, and all 10 pre-built agent skills. There are no feature limitations in the free tier. Pricing for commercial use is based on team size and usage volume.