Intento node is the daemon, called intentod, that runs the Intento blockchain, a free and open-source client written in Go. It is built for developers and node operators who want to schedule blockchain actions that fire when defined conditions are met. Because it belongs to the Cosmos ecosystem, readers who already run or study Cosmos-based chains will find the setup familiar.
The project is actively maintained. Its latest tagged release is v1.1.0-hotfix.13, and the code was last updated on February 24, 2026. This guide covers what the node does, what to check before installing it on Windows, and how it compares with other node clients. Where Windows availability depends on a specific release, we point you to the releases page instead of guessing.
What Is an Intent-Driven Blockchain?
Most blockchain transactions are immediate. You sign a message, and the network processes it right away. An intent-driven model works differently: you describe the outcome you want and the conditions under which it should happen, and the network carries out the steps when those conditions are met.
Imagine you want a transfer on one chain to be followed by an action on another chain, but only if a balance or a confirmation meets a threshold you set in advance. Doing this by hand means watching the chains and submitting each transaction at the right moment. An intent-driven system moves that waiting and checking onto the network.
The idea has trade-offs. Conditional actions are only as reliable as the inputs they read, and every step still costs fees on the network where it runs. Fees depend on the chain, so check them before you set up a long sequence. Understanding this model is the first step to using Intento node effectively.
Who Should Run Intento Node?
Intento node suits developers who build cross-chain automation and want to test flows against a real Cosmos-based network. It also fits node operators who already maintain Cosmos infrastructure and want to add interchain orchestration to their setup.
Researchers and students can use it to study how interchain accounts, IBC hooks and triggers work together. Running a node locally shows the mechanics more clearly than reading documentation alone, because you can watch the daemon sync and process flows.
It is less suited to people who want a one-click application for everyday payments. The node is command-line software, and it expects you to understand keys, configuration files and network settings. If that sounds unfamiliar, spend time with the official documentation before you deploy anything with real value behind it.
Key Concepts: Interchain Accounts, IBC Hooks and Triggers
A node, or daemon, is the program that connects your computer to a blockchain network. It stores chain state, validates incoming data and processes requests. Intento node runs as intentod, and it is the component that evaluates your conditions and executes the actions attached to them.
Interchain Accounts let one chain control an account that lives on another chain. In practice, this means an action initiated on one network can operate on assets held elsewhere, as long as the permissions are in place. IBC, the Inter-Blockchain Communication protocol, provides the messaging layer that makes this possible across Cosmos chains.
IBC hooks extend that messaging layer so that an incoming packet can trigger logic on the receiving chain. A trigger address is the fixed identity that carries out your permitted actions. Keeping it unique and well documented makes it easier to audit what the node is allowed to do on your behalf.
Key features
Self-custodial execution
Permissionless access
TriggerPortal interface
Orchestration of complex operations
VM-agnostic execution
IBC-native coordination
Modular and secure foundation
Privileged execution with a trigger address
Recorded on-chain
Supported coins
The project's documentation points to Cosmos (ATOM) as the network it is built around. Because Intento runs as a node within the Cosmos ecosystem, it is most useful for readers who already work with Cosmos chains, Interchain Accounts and IBC. Check the documentation for the current list of connected chains before you plan a workflow that depends on a specific network.
How to install Intento node on Windows
- 1
Choose the release
Go to the official website or the project's GitHub Releases page at github.com/trstlabs/intento. Look for the latest tagged release, currently v1.1.0-hotfix.13, and confirm that a Windows build is published for that version. If only source code is listed, you will need to build it yourself, which requires a Go toolchain.
- 2
Verify the file
Download only from the official website or the GitHub Releases page. Compare the SHA-256 checksum of the downloaded file with the value published next to it. If the project provides a signature, verify that as well. Do not continue if the values do not match.
- 3
Place the program
Extract the archive and move the intentod executable to a dedicated folder, such as C:\Tools\intento. Keeping it in one place makes updates and rollbacks easier. Optionally add that folder to your PATH so you can run the command from any terminal window.
- 4
Initialize the node
Open a terminal in that folder and run the initialization command described in the official documentation for the network you want to join. This creates the configuration and data directories. Review the generated configuration files before starting the node, paying attention to ports and peer settings.
-
Start and sync
Launch the node and let it sync with the network. Synchronization can take a long time and depends on your connection and disk speed. Keep the terminal open or run the node as a service, and check the logs for errors during the first sync.
How to use Intento node
Using Intento node has two parts: running the daemon and submitting flows. Set up the node first, then use the interface to describe what you want to happen.
- Start the node and wait until it is fully synced with the network.
- Open TriggerPortal, the frontend for building flows, and connect it to your node.
- Define the condition that should start the action, such as a balance or confirmation you want to watch.
- Specify the action or sequence of interchain steps that should run once the condition is met.
- Grant the required permissions to your trigger address, limiting them to the actions the flow needs.
- Submit the flow on-chain and note the identifier or transaction reference for tracking.
- Review the execution history afterward to confirm each step ran as expected.
Start with a small, low-risk test before you automate anything meaningful. Once you understand how your flows behave, you can build more complex sequences with confidence.
Pros & cons
- Free and open source, with source code available on GitHub
- Written in Go and built on the Cosmos SDK
- Recent maintenance, with the last code update in February 2026
- Self-custodial design that keeps you in control of permissions
- Permissionless, so anyone can run the node and submit flows
- TriggerPortal provides a frontend for building flows
- Uses Interchain Accounts and IBC hooks for cross-chain actions
- Command-line setup is technical and may be hard for beginners
- Windows availability depends on the release, so check before installing
- Designed for Cosmos-based workflows, which limits use for other ecosystems
- Conditional automation still depends on the networks and inputs it reads
- Running a node requires disk space, time for sync and ongoing attention
Is Intento node safe?
Download only from the official website or the project's GitHub repository at github.com/trstlabs/intento, and use the Releases page for the tagged build. Compare the SHA-256 checksum of the file with the published value, or verify the signature if one is provided. Never enter a seed phrase, private key or validator mnemonic on a third-party website, and treat unsolicited help offers with suspicion. Because this software can authorize actions on your account, keep key backups offline and limit permissions to what each flow needs. The project has been updated recently, but check the latest version on the official website before installing.
- Official source only. Download from github.com/trstlabs/intento. Ignore ads and lookalike domains.
- Check the SHA-256. Compare the installer hash with the value the developer publishes before running it.
- Never share your seed phrase. No developer, support agent or website — including CryptApps — will ever ask for it.
Alternatives
Cosmos Hub's gaiad runs the Cosmos Hub itself, so it is the right choice if you need to operate that chain's core node. Intento node focuses on orchestrating conditional actions across chains rather than acting as the hub's main node. Celestia App provides the consensus layer for Celestia's data availability network, and Evmos brings an EVM-compatible environment to the Cosmos ecosystem. Geth and Bitcoin Core are client implementations for Ethereum and Bitcoin, built around different designs. Choose Intento if your goal is cross-chain action orchestration, and choose a chain-specific client if you need to run that network.
Specifications
- Price
- Free
- Type
- Open source
- License
- —
- Latest version
- v1.1.0-hotfix.13
- Last update
- 24 Feb 2026
- Windows support
- Likely (builds for Windows; check releases)
- Source code
- github.com/trstlabs/intento
Frequently asked questions
Yes, Intento node is free and open source, and its source code is published on GitHub. There is no price to pay for the software itself. Network fees may apply when you submit flows or execute transactions on-chain, and those depend on the chain where the action runs.
The project's build setup includes Windows, but availability depends on the specific release. Check the GitHub Releases page for a Windows build of the version you want. If only source code is published, you will need a Go toolchain to compile it yourself.
It can be safe if you install it correctly. Download only from the official website or GitHub, verify the SHA-256 checksum or signature, and never enter a seed phrase on a third-party website. Keep your keys backed up offline and limit permissions to the actions each flow requires.
You start the node, let it sync with the network, and then use the TriggerPortal interface to build a flow. A flow defines a condition, an action and the permissions needed for that action. After you submit it on-chain, you can track its execution.
Intento node is used to run conditional, cross-chain actions on the Intento blockchain. Developers use it to automate multi-step operations that should start when certain conditions are met. It relies on Cosmos mechanisms such as Interchain Accounts and IBC hooks.
The project's documentation references Cosmos (ATOM) as the network it is built around. Intento node is part of the Cosmos ecosystem, so it is most relevant for workflows involving Cosmos chains. Check the documentation for the current list of connected networks.
No, Intento node is a blockchain daemon rather than a wallet. It runs the node software, evaluates conditions and executes permitted actions. You still manage keys and permissions yourself, so keep them secure whichever tools you use.
Verdict
Intento node is a good fit for developers, node operators and researchers who want to automate cross-chain actions within the Cosmos ecosystem. It is free, open source and recently maintained, and its self-custodial design gives you control over permissions. It is not a casual app, though. The setup is technical, Windows availability depends on the release, and you should test flows carefully before relying on them with real funds.