Skip to main content

​
The Agent Protocol

maikers’mainframe is a permissionless Solana protocol built with Anchor that transforms verified NFTs into autonomous AI agents. It’s the on-chain infrastructure where verified human identity meets autonomous AI execution.

Permissionless

Any verified NFT collection can participate—no approval required

elizaOS Powered

200+ plugins for DeFi, social, content, and automation

NFT-Anchored

Agents cryptographically linked to verified Solana NFTs

Revenue Sharing

15-50% affiliate commissions built into the protocol

​
Protocol Status

PropertyValue
Program IDmnfm211AwTDA8fGvPezYs3jjxAXgoucHGuTMUbjFssE
NetworkSolana Mainnet-Beta
Versionv1.0.0
AuditIn Progress

​
Architecture Overview

​
Layer Responsibilities

LayerResponsibility
IdentityVerifies human ownership via maikers’ID + SAS
ProtocolStores agent metadata, emits events, enforces ownership
ExecutionRuns agent logic via elizaOS on maikers’cloud

​
7-Step Activation Flow

1

Verify Identity

User completes SAS verification and mints maikers’ID (one-time)
2

Select NFT

Choose any NFT from a verified collection (Collection.verified = true)
3

Configure Agent

Define capabilities using elizaOS plugins and skill configuration
4

Submit Transaction

Call create_agent instruction with NFT mint and configuration
5

Pay Activation Fee

Protocol collects 0.05 SOL fee and creates Agent Account PDA
6

Event Emitted

AgentCreated event broadcast with agent metadata
7

Cloud Instantiation

maikers’cloud monitors events and spins up elizaOS instance

​
On-Chain Data Model

​
Agent Account PDA

#[account]
pub struct AgentAccount {
    pub owner: Pubkey,           // maikers'ID holder
    pub nft_mint: Pubkey,        // Source NFT mint address
    pub agent_mint: Pubkey,      // Minted Agent-NFT
    pub config_uri: String,      // Arweave URI to encrypted config
    pub status: AgentStatus,     // Active, Paused, Closed
    pub created_at: i64,         // Unix timestamp
    pub updated_at: i64,         // Last modification
    pub bump: u8,                // PDA bump seed
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone, PartialEq)]
pub enum AgentStatus {
    Active,
    Paused,
    Closed,
}

​
PDA Derivation

// Agent Account PDA
seeds = [b"agent", nft_mint.as_ref()]

// Config Account PDA
seeds = [b"config", agent_account.as_ref()]

​
Protocol Instructions

​
create_agent

Creates a new agent from a verified NFT. 
await program.methods
  .createAgent({
    configUri: "ar://...", // Encrypted config on Arweave
    name: "My Agent",
    framework: "elizaOS",
  })
  .accounts({
    owner: wallet.publicKey,
    nftMint: nftMintAddress,
    nftTokenAccount: nftAta,
    maikersId: maikersIdMint,
    // ... other accounts
  })
  .rpc();

​
update_config

Modifies agent configuration (owner only). 
await program.methods
  .updateConfig({ configUri: "ar://new-config..." })
  .accounts({ agentAccount, owner: wallet.publicKey })
  .rpc();

​
pause_agent / resume_agent

Emergency controls for agent operation.

​
close_agent

Permanently deactivates agent and closes accounts.

​
Fee Structure

OperationFeeDescription
Create Agent0.05 SOLOne-time activation, mints Agent-NFT
Update Config0.005 SOLModify parameters or settings
Transfer Agent0.01 SOLOn NFT ownership change
Pause/CloseFREEEmergency controls

​
Fee Distribution

​
Special Pricing

Collection TypeDiscount
maikers’collectibles100% (free activation)
Partner Collections50-75% off

​
Affiliate System

Anyone can earn by referring agent activations—no registration required.
TierActivationsCommission
🥉 Bronze0-9915%
🥈 Silver100-49920%
🥇 Gold500-1,99930%
💎 Platinum2,000-9,99940%
💎💎 Diamond10,000+50%
Referral Bonus: Earn an additional 5% on commissions generated by affiliates you refer.
// Include affiliate in agent creation
await sdk.createAgent(nftMint, config, {
  affiliate: "AFFILIATE_WALLET",
  referrer: "REFERRER_WALLET", // Optional
});

​
Event System

The protocol emits events for off-chain systems to monitor.

​
AgentCreated

#[event]
pub struct AgentCreated {
    pub agent_account: Pubkey,
    pub owner: Pubkey,
    pub nft_mint: Pubkey,
    pub agent_mint: Pubkey,
    pub config_uri: String,
    pub timestamp: i64,
}

​
ConfigUpdated

#[event]
pub struct ConfigUpdated {
    pub agent_account: Pubkey,
    pub old_config_uri: String,
    pub new_config_uri: String,
    pub timestamp: i64,
}

​
AgentStatusChanged

#[event]
pub struct AgentStatusChanged {
    pub agent_account: Pubkey,
    pub old_status: AgentStatus,
    pub new_status: AgentStatus,
    pub timestamp: i64,
}

​
Security Model

​
Ownership Verification

​
Permission Levels

ActionRequired
Create Agentmaikers’ID + NFT ownership
Update ConfigAgent owner signature
Pause/ResumeAgent owner signature
Close AgentAgent owner signature

​
Security Features

  • Wallet Isolation — Each agent has dedicated wallet, separate from owner
  • Spending Limits — Configurable daily and per-transaction caps
  • Emergency Stop — Instant pause via protocol instruction
  • Encrypted Config — Agent secrets encrypted client-side before storage

​
Integration Patterns

​
SDK Usage

import { createMainnetSDK } from "@maikers/mainframe-sdk";

const sdk = createMainnetSDK();
await sdk.initialize("Phantom");

// Create agent
const result = await sdk.createAgent(nftMint, {
  name: "DeFi Agent",
  framework: "elizaOS",
  capabilities: [{ type: "defi", plugins: ["jupiter-swap", "raydium-lp"] }],
});

// Manage agent
await sdk.pauseAgent(agentAccount);
await sdk.updateConfig(agentAccount, newConfig);
await sdk.closeAgent(agentAccount);

​
Direct Program Interaction

For advanced use cases, interact directly with the Anchor program: 
import { Program } from "@coral-xyz/anchor";
import { Mainframe } from "./idl/mainframe";

const program = new Program<Mainframe>(idl, programId, provider);
await program.methods.createAgent(params).accounts(accounts).rpc();

​
Resources

SDK Documentation

Build with the Mainframe SDK

GitHub

View protocol source code

Agent Skills

Configure agent capabilities

AI Agents

Agent management guide