Talus Network: Revolutionizing AI with Onchain Smart Agents

Talus Network is a Layer-1 blockchain designed specifically for Smart Agents, offering speed, security, and liquidity. Built using the MoveVM, Talus simplifies the development, ownership, and monetization of composable Smart Agents. This allows developers to create AI applications that operate autonomously on behalf of users, handling tasks and transactions without direct human intervention.

What are Smart Agents?

Smart Agents are individualized AI applications that act autonomously to achieve user-defined goals. Unlike traditional AI, Smart Agents can take real-world actions, such as executing transactions, managing portfolios, or acting as a DAO proxy voter. Onchain Smart Agents leverage blockchain technology for enhanced security and transparency.

Talus Network Use Cases

Talus empowers a wide range of applications for Smart Agents:

• DeFi: Automated liquidity management, omnichain smart agents, and onchain index funds enhance DeFi applications with increased liquidity, advanced financial tools, and improved risk management.
• Gaming and Social: Smart Agents can personalize gaming experiences, automate tasks, and facilitate social interactions within games and online communities.
• DePin: Decentralized applications can integrate Smart Agents to automate processes, improve efficiency, and create new interactive experiences.
• DAOs: Smart Agents can serve as DAO proxy voters, streamlining governance and decision-making processes.
• AI and Data Ecosystem: Talus provides a robust infrastructure for the development and deployment of AI-powered Smart Agents, fostering innovation within the broader AI ecosystem.

Building on Talus

Talus provides developers with native tools and primitives for building onchain Smart Agents. The platform's MoveVM compatibility ensures seamless integration and efficient execution of Smart Agent code.

use talus::agent::{AgentName, AgentBlueprint};
use talus::task::TaskBlueprint;

// === Data models ===

/// An object that holds a cluster definition.
public struct Cluster has key, store {
  id: UID,
  blueprint: ClusterBlueprint,
}

/// Usually an owned object that permissions operations on the [`Cluster`].
public struct ClusterOwnerCap has key, store {
  id: UID,
  cluster: ID,
}

/// Blueprint for execution.
public struct ClusterBlueprint has store, copy, drop {
  name: String,
  description: String,
  tasks: vector<TaskBlueprint>,
  agents: VecMap<AgentName, AgentBlueprint>,
}

// === Constructors ===

/// Create an empty [`Cluster`] shared object.
/// The tx sender gets an owned object [`ClusterOwnerCap`] that allows them to
/// modify the cluster.
public entry fun create(
  name: String,
  description: String,
  ctx: &mut TxContext
) {
  let cluster = Cluster {
    id: object::new(ctx),
    blueprint: ClusterBlueprint {
      name,
      description,
      agents: vec_map::empty(),
      tasks: vector::empty(),
    }
  };

  let owner_cap = ClusterOwnerCap {
    id: object::new(ctx),
    cluster: object::id(&cluster),
  };

event::emit(ClusterCreatedEvent {
  cluster: object::id(&cluster),
  owner_cap: object::id(&owner_cap),
});

transfer::share_object(cluster);
transfer::transfer(owner_cap, ctx.sender());
}

Recent News

• Talus x Chasm: Partnership to seamlessly deploy AI Smart Agents.
• Bi-Monthly Recap: Summary of recent developments and updates.
• Talus x Ankr: Integration with Ankr for Bitcoin liquidity for onchain Smart Agents.

Join the Talus Network

Become a part of the Smart Agent revolution by joining the Talus community and exploring the possibilities of onchain AI.