Leo — 129 Operations for AI Agents

Leo programs compile to zero-knowledge circuits on Aleo, where privacy is the default. act101 navigates transitions, records, and mappings structurally, so agents review private-by-design logic precisely.

This page is the canonical reference an AI coding agent uses to refactor, query, and analyze Leo code through the act MCP server. 129 operations available: 55 refactor, 18 query, 42 analysis, 14 verification. Each operation is callable from Claude Code, Cursor, Codex, OpenCode, or any MCP-compatible agent host. Click any operation for a stable anchor link suitable for citation.

Premium language. Operations on Leo require an Elite license or above. See pricing.

Worked Leo examples

act101 parses Leo programs into their program, record, struct, and transition structure, so an edit resolves against a specific declaration rather than a text match. It can add the owner: address field an Aleo record needs, inserted as the record's first field. It can flip a transition parameter from private to public by adding the public keyword. It can extract a subset of a struct's fields into a new struct, replacing them with a single field of the new struct's type. It can attach a finalize block to an existing transition, so the transition gains on-chain state updates alongside its off-chain computation. And it can merge two named transitions into one, preserving the first signature, dropping the first's final return, and appending the second body. Each example below is the verbatim output of the command shown, run against the file shown.

Add an owner field to a record

token.aleo's Balance record has an amount field but no owner, which every Aleo record requires.

$ act refactor-lang add_owner_field --file token.leo --params '{"record_name":"Balance","owner_field":"owner","line":1,"column":1}'

Before

program token.aleo {
  record Balance { amount: u64, }
}

After

program token.aleo {
  record Balance {
    owner: address,
    amount: u64,
  }
}

owner: address is inserted as the record's first field, ahead of amount.

Convert a transition parameter to public

bank.aleo's deposit transition takes amount as a private parameter.

$ act refactor-lang convert_private_to_public --file bank.leo --params '{"transition_name":"deposit","parameter_name":"amount","line":1,"column":1}'

Before

program bank.aleo {
  transition deposit(amount: u64) -> u64 {
    return amount;
  }
}

After

program bank.aleo {
  transition deposit(public amount: u64) -> u64 {
    return amount;
  }
}

amount: u64 becomes public amount: u64, so the value is visible on-chain instead of staying private to the prover.

Extract struct fields into a new struct

accounts.aleo's Account struct has owner, balance, and nonce fields, and owner/nonce should move into their own struct.

$ act refactor-lang extract_struct --file accounts.leo --params '{"struct_name":"Account","new_struct_name":"AccountMeta","new_field_name":"meta","field_names":["owner","nonce"],"line":1,"column":1}'

Before

program accounts.aleo {
  struct Account { owner: address, balance: u64, nonce: u64, }
}

After

program accounts.aleo {
  struct AccountMeta {
    owner: address,
    nonce: u64,
  }

  struct Account {
    meta: AccountMeta,
    balance: u64,
  }
}

A new AccountMeta struct holds owner and nonce; Account keeps balance and gains a meta: AccountMeta field in their place.

Attach a finalize block to a transition

bank.aleo's deposit transition takes a public amount and returns it, with no on-chain state update yet.

$ act refactor-lang gen_finalize_block --file vault.leo --params '{"transition_name":"deposit","finalize_name":"update","parameter_name":"amount","parameter_type":"u64","line":1,"column":1}'

Before

program bank.aleo {
  transition deposit(public amount: u64) -> u64 {
    return amount;
  }
}

After

program bank.aleo {
  transition deposit(public amount: u64) -> u64 {
    return amount;
  } finalize update(public amount: u64) {
    let total: u64 = amount;
  }
}

A finalize update(public amount: u64) { let total: u64 = amount; } block is appended directly after deposit's closing brace.

Merge two transitions into one

token.aleo declares two separate transitions, first and second, each computing its own value from the same seed parameter.

$ act refactor-lang merge_transitions --file combine.leo --params '{"first_transition":"first","second_transition":"second","merged_name":"combined","line":1,"column":1}'

Before

program token.aleo {
  transition first(seed: u64) -> u64 {
    let a: u64 = seed + 1u64;
    return a;
  }

  transition second(seed: u64) -> u64 {
    let b: u64 = seed + 2u64;
    return b;
  }
}

After

program token.aleo {
  transition combined(seed: u64) -> u64 {
    let a: u64 = seed + 1u64;
    let b: u64 = seed + 2u64;
    return b;
  }

}

The two transitions become one, combined, keeping first's signature: both let computations run in sequence, and the final return b; from second is what the merged transition returns.

Query

18 query tools, the same on every supported language. Descriptions live in the shared reference: /docs/query-tools.

callers control_flow data_flow definition diagnostics effect_closure effect_summary fix_auto get_type graph import_organize interface mutations references repo_outline skeleton symbols symbols_batch

Refactor

Analysis

42 analysis tools, the same on every supported language. Descriptions live in the shared reference: /docs/analysis-tools.

analyze_api_diff analyze_chokepoints analyze_clones analyze_clusters analyze_cohesion analyze_conformance analyze_coupling analyze_cycle_risk analyze_cycles analyze_dead_code analyze_depth analyze_entry_points analyze_export analyze_extraction analyze_fan_balance analyze_features analyze_hotspots analyze_impact analyze_inconsistencies analyze_inheritance analyze_interface_bloat analyze_interfaces analyze_layers analyze_orphan_types analyze_patterns analyze_platform_deps analyze_readiness analyze_roles analyze_seams analyze_stability analyze_surface analyze_test_gaps analyze_thickness analyze_type_completeness churn_hotspots co_change_clusters coverage_overlay ownership_map profile_overlay simulate split_module trace_overlay

Verify

14 verify tools, the same on every supported language. Descriptions live in the shared reference: /docs/verification.

bisect_regression gate generate_test_harness scan secret_surface summarize_pr taint_flow unsafe_surface verify_behavioral_equivalence verify_contract_preserved verify_diff_semantics verify_port_parity verify_side_effects verify_test_impact