Skip to content
Stork.AIstork.ai
AI Tool

act101 Review

act101 is a deterministic merge gate and AST refactoring tool for coding agents, enabling refactoring, code porting, change classification, and deterministic merge verdicts across 163 languages.

shipped Aug 11, 2026agentsfreemium
Domain rating26Monthly visits4/mo
agentscoderesearch
act101 — product screenshot

Why it matters

1Supports refactoring and porting code across 163 programming languages.
2Provides a deterministic MERGE/REVIEW/BLOCK verdict for AI-authored code changes.
3Offers 41 codebase analyzers and 183 refactoring operations.
4Includes a free Builder Edition for non-commercial use.

About act101

Business Model
Subscription SaaS
Usage Pricing
~88% fewer tokens on query operations per token
Platforms
macOS, Linux, Windows, API
Target Audience
Engineers looking for code refactoring tools that support AI agents.

Pricing Plans

Builder Edition
$0 / monthly
  • • 15 query operations
  • • 5 codebase analyzers
  • • Rename + fix-auto
  • • 138 of 163 grammars
Engineering Edition
$29 / monthly
  • • Everything in Builder
  • • Extract, inline, wrap, introduce
  • • Generated constructors & accessors
  • • Refactor verification & receipts
Architecture Edition
$59 / monthly
  • • Everything in Engineering
  • • Structural refactors & decomposition
  • • Code scaffolding tools
  • • Whole-codebase taint + git overlays
Elite Edition
$99 / monthly
  • • Everything in Architecture
  • • Legacy: COBOL, Fortran, Ada…
  • • Blockchain: Solidity, Vyper…
  • • GPU & shaders: CUDA, GLSL, HLSL, WGSL

Cost Examples

  • • Engineering Edition is approximately the tokens one whole-file rewrite wastes
  • • Architecture Edition is approximately the tokens two whole-file rewrites waste
  • • Elite Edition is approximately the tokens three whole-file rewrites waste

Leadership

Not mentioned
API DocsGitHub

overview

What is act101?

act101 is an AI-powered code quality layer developed by act101.ai that enables individual engineers, codebase owners, and architects to analyze, refactor, and attest to changes from coding agents. It focuses on providing provable change safety and behavioral equivalence for AI-generated code, addressing the bottleneck of "proof" in agentic software development. The tool operates on a three-stage workflow: Analyze, Act, and Attest. The Analyze stage utilizes 41 codebase analyzers to identify issues like dead code, cycles, and coupling. The Act stage offers 183 refactoring operations for transformations across multiple files. The Attest stage involves 6 verification operations and a deterministic merge gate that classifies changes, identifies relevant tests, diffs side-effects, and provides a MERGE/REVIEW/BLOCK verdict with a signed receipt and one-command rollback. This ensures behavioral equivalence and provable change safety across 163 supported grammars, including COBOL, Fortran, Ada, Verilog, and Solidity.

features

Key Features of act101

act101 provides a suite of features designed for robust AI-assisted code development and verification, emphasizing deterministic outcomes and broad language support.

  • Deterministic merge gate: Provides a MERGE/REVIEW/BLOCK verdict for AI-authored code changes with a signed receipt and one-command rollback.
  • AST-aware refactoring: Offers 183 refactoring operations for transformations such as renaming, extracting, inlining, moving, and modernizing code.
  • Agentic code transformation: Enables AI agents to refactor and port code across 163 programming languages.
  • Real-time analysis and attestation: Utilizes 41 codebase analyzers to map code for issues like dead code, cycles, coupling, and hotspots.
  • Code porting and modernization: Supports porting legacy codebases across languages (e.g., C to Rust, Ruby to Elixir) with behavioral equivalence verification.
  • AI-Code Health Scoring: Provides a GitHub-native health scanner for AI-authored code, delivering grades via PR comments, Check Runs, and SARIF uploads.
  • Secrets Protection: Sequester plaintext .env files into an out-of-repo store, leaving only key names in the committed .env file.
  • Free for open-source and non-commercial use: The Builder Edition is available at no cost for non-commercial projects.

use cases

Who Should Use act101?

act101 is designed for technical professionals and organizations engaged in software development, particularly those leveraging AI coding agents or managing complex, multi-language codebases.

  • Individual engineers: For refactoring code with AI agents, porting code across 163 languages, and verifying AI-authored changes.
  • Codebase owners: For maintaining code health and architectural integrity, analyzing code for issues like dead code and coupling.
  • Architects: For ensuring provable change safety and preventing architectural drift in AI-assisted development.
  • Developers using AI coding agents: For obtaining deterministic verdicts on merges and ensuring behavioral equivalence of AI-generated code.
  • Research and product development teams: For leveraging advanced code analysis and transformation capabilities across a wide array of programming languages.

how to use

How to Use act101

act101 integrates into existing development workflows to analyze, transform, and verify code changes, particularly those generated by AI agents. The process typically involves configuring the tool to monitor a codebase and then applying its analysis and refactoring capabilities.

  • 1Integrate act101 with your GitHub repository for AI-code health scanning and PR comment feedback.
  • 2Utilize the 41 codebase analyzers to identify structural issues, dead code, and architectural problems.
  • 3Apply 183 refactoring operations to transform and modernize code across multiple files and 163 languages.
  • 4Employ the deterministic merge gate to verify AI-authored code changes, receiving a MERGE/REVIEW/BLOCK verdict.
  • 5Leverage the one-command rollback feature for verified changes to revert if necessary.
  • 6Configure secrets protection to manage sensitive .env files securely outside the repository.

pricing

act101 Pricing & Plans

act101 operates on a freemium model, offering a free tier for non-commercial use and tiered subscriptions for professional engineering and architectural needs. The pricing structure is designed to scale with the complexity and volume of code transformations and analyses required.

  • Builder Edition: $0 per month. This tier is free forever for open-source and non-commercial use, providing access to core features.
  • Engineering Edition: $29 per month. This tier is approximately equivalent to the tokens wasted by one whole-file rewrite, offering enhanced capabilities for individual engineers.
  • Architecture Edition: $59 per month. This tier is approximately equivalent to the tokens wasted by two whole-file rewrites, suitable for architects and teams requiring more extensive analysis and refactoring.
  • Elite Edition: $99 per month. This tier is approximately equivalent to the tokens wasted by three whole-file rewrites, providing the most comprehensive features for advanced use cases.

Pros

  • +Provides deterministic MERGE/REVIEW/BLOCK verdicts for AI-authored code changes, enhancing reliability.
  • +Supports refactoring and porting code across an extensive list of 163 programming languages.
  • +Offers 41 codebase analyzers for deep structural analysis, identifying issues like dead code and architectural problems.
  • +Includes 183 refactoring operations for comprehensive code transformations.
  • +Features a free Builder Edition for non-commercial and open-source projects.
  • +Achieves 88% token efficiency on query operations compared to whole-file rewrites.

Cons

  • −Requires integration into existing CI/CD pipelines, which may involve initial setup effort.
  • −The extensive feature set and technical depth may present a learning curve for new users.
  • −Specific user reviews with ratings are not readily available in the provided data, making broad reception assessment difficult.
  • −While supporting 163 languages, the depth of refactoring operations might vary across less common grammars.

Similar Tools

act101 vs Competitors

act101 differentiates itself in the code transformation and verification landscape through its focus on deterministic merge gates, broad language support, and explicit behavioral equivalence verification for AI-authored code.

1
OpenRewrite↗

Provides a framework for declarative, automated code refactoring and transformation using recipes, primarily for Java but expanding to other languages.

OpenRewrite excels at applying large-scale, predefined code transformations based on ASTs. However, it doesn't offer the built-in 'deterministic merge gate' or 'deterministic verdict on merges' that act101 provides, requiring custom integration for merge conflict resolution.

2
jscodeshift↗

A toolkit and runner for writing and applying codemods (automated code transformations) specifically for JavaScript and TypeScript using ASTs.

jscodeshift is highly effective for programmatic refactoring in JavaScript/TypeScript, similar to act101's AST refactoring capabilities. The trade-off is its language specificity and the absence of a direct 'deterministic merge gate' feature for automated conflict resolution across different codebases.

3
Comby↗

A structural code search and replace tool that works across many programming languages by understanding code structure without full parsing.

Comby offers a versatile way to perform structural code transformations and refactorings programmatically, which aligns with act101's code manipulation aspect. However, it operates on concrete syntax rather than full ASTs for deeper semantic understanding, and it lacks the explicit 'deterministic merge gate' functionality for agent-driven merge decisions.

4
tree-sitter↗

A parser generator and incremental parsing library that builds concrete syntax trees (CSTs) for many languages, enabling robust code analysis and transformation.

tree-sitter provides the foundational technology for building highly precise AST/CST-based refactoring tools, similar to the underlying mechanism act101 would use. The trade-off is that tree-sitter is a library, not a complete tool, meaning you would need to develop the higher-level 'merge gate' and 'deterministic verdict' logic yourself, which act101 provides out-of-the-box.

More on Stork

Related AI Tools

Other tools in this category, matched by shared tags

PayAPI MarketSnapIQPushfyModelVaultRealword AIIO Inventory
Visit act101↗
Connect
𝕏
X / Twittertwitter.com/act101ai
⌘
GitHubgithub.com/act101-ai/act101
in
LinkedInwww.linkedin.com/company/act101