Technology Overview

Intentify’s technology stack is built around two core components that work in tandem to enable secure, transparent, and efficient intent-based interactions on Ethereum: the Engine, an on-chain virtual machine, and IAML, a domain-specific language tailored for intent execution.

Engine: On-Chain Virtual Machine

At the heart of Intentify lies the Engine, an optimized monolithic contract written in Huff. This contract functions as an external account module, serving as a specialized virtual machine designed specifically for executing user intents.

Architecture

Unlike traditional stack machines, the Engine operates as a register machine. This architectural choice brings several important advantages. By separating program logic from data parameters, the Engine makes it easier to inspect and debug the execution state. This clear logic-data separation also allows account behavior to remain fixed while parameters can be dynamically configured as needed. As a result, the Engine achieves significantly better performance compared to stack-based alternatives.

EVM Compatibility

To ensure familiarity and seamless integration, the Engine is designed to closely resemble the Ethereum Virtual Machine (EVM). Most EVM opcodes are implemented with equivalent behavior, making it easy for developers to adapt. At the same time, the Engine introduces specialized features for native intent processing, allowing it to work smoothly within the existing Ethereum infrastructure.

Account Integration

The Engine integrates with Intentify’s gas-optimal account implementation. Nevertheless, this architecture is equally compabtible with smart accounts (EIP-7702/ERC-4337) which support external account modules. Thus, making the Engine’s benefits accessible to all blockchain users.

IAML: Domain-Specific Language

IAML (Intent yAML) is a high-level domain-specific language that compiles to executable bytecode for the Engine. It is purpose-built to address the critical problem of blind signing while empowering developers with robust intent-based programming capabilities.

Syntax Comparison

To illustrate IAML’s simplicity, consider a basic token transfer operation. Here’s how the same functionality would be implemented in Solidity versus IAML:

Solidity:

function transferToken() external {
    address tokenAddress = 0xA0b86a33E6441b39a1e4A0b86d3E11BF0b2b1e4a;
    address recipient = 0x742d35Cc6634C0532925a3b8D2A47c1A9A5a5fB7;
    uint256 amount = 100 * 10**18;
    
    IERC20(tokenAddress).transfer(recipient, amount);
}

IAML:

contracts:
  token:
    abi: std/erc20
    address: 0xA0b86a33E6441b39a1e4A0b86d3E11BF0b2b1e4a
 
constants:
  recipient: !Address 0x742d35Cc6634C0532925a3b8D2A47c1A9A5a5fB7
  amount: !Uint 100 * 10**18
 
workflow:
  - token.transfer(recipient, amount)

The IAML version is not only more concise and readable for end users, but also immediately executable. Unlike the Solidity snippet, which requires contract deployment, funding, and complex infrastructure setup, the IAML workflow can be executed directly from any user’s account. This eliminates deployment friction and makes intent execution accessible to any user without requiring them to become smart contract developers.

Design Philosophy

IAML strikes a careful balance between expressiveness and simplicity, prioritizing user understanding and security over raw computational power. The language is built around three core design principles that work together to create a secure and accessible intent execution environment.

Transparency Over Complexity: IAML scripts are designed to be immediately readable by end users, not just developers. Every operation is expressed in clear, declarative syntax that makes it obvious what will happen when the intent executes. The compiler is available as a WebAssembly module, enabling client-side compilation so users can verify exactly what they’re signing without relying on external services.

Configuration Over Programming: IAML is designed to feel invisible in the development flow. The language wraps familiar Solidity syntax into YAML, a widely-used data serialization format commonly seen in configuration systems like Kubernetes and Ansible. Rather than complex programming, IAML focuses on orchestrating contract interactions. Adding and removing instructions is as simple as adding or removing items on a shopping list. Integrated with the SDK, these scripts become simple configuration files that can be easily iterated on from within any app’s codebase.

Orchestration Over Implementation: IAML intentionally limits complexity to focus on its core strength: coordinating interactions between existing smart contracts. The language supports comprehensive EVM operations and native intent processing features, but deliberately avoids custom function definitions or complex control structures. This constraint ensures that IAML remains a clear integration layer rather than a general-purpose programming environment, keeping scripts auditable and understandable.