DEV Community: kenneth okenwa

Building Autonomous AI Agents on Solana: A Hands-On Guide with Solana Agent Kit and LangChain

kenneth okenwa — Fri, 16 Oct 2026 12:50:19 +0000

By Kenneth Okenwa (@symplyKen | GitHub: @anekenonso)

1. Why Solana is the Settlement Layer for the AI Agent Economy

As artificial intelligence shifts from passive conversational assistants to autonomous economic actors, agents require an underlying financial rail. They need to pay for compute APIs, purchase data datasets, rebalance liquidity pools, and tip other agents for micro-tasks.

Traditional payment rails (Stripe, bank wires, credit cards) fail completely for AI agents: they require identity KYC, manual human onboarding, and impose heavy minimum fee floors (e.g., $0.30 + 2.9%), making 5-cent agent-to-agent transactions economically unviable.

Ethereum and high-fee EVM networks also present severe roadblocks: unpredictable gas auction spikes and multi-second block confirmations break high-frequency reasoning loops.

Solana provides the ideal substrate for autonomous AI agents:

Sub-Second Finality: ~400ms block times ensure agents can act with real-time speed.
Micro-Cent Transaction Fees: Average transaction fees of <$0.001 allow agents to conduct thousands of autonomous micro-operations daily without balance depletion.
Parallelized SVM Execution: The Sealevel runtime processes non-overlapping transactions concurrently, preventing localized DeFi activity from freezing an agent's operations.
Rich Composable Ecosystem: Deep liquidity on Jupiter DEX, compressed NFTs (cNFTs) for low-cost metadata attestation, and established SPL token standards.

In this developer guide, we walk through building an autonomous AI agent capable of reasoning, inspecting on-chain state, and executing live Solana transactions using the Solana Agent Kit and LangChain.

2. Architecture: How On-Chain AI Agents Work

An on-chain AI agent combines a high-level cognitive engine with deterministic blockchain execution tools:

┌──────────────────────────────────────────────────────────────┐
│                   Human Operator / Prompt                    │
│      "Check my SOL balance and swap 0.1 SOL to USDC"         │
└──────────────────────────────┬───────────────────────────────┘
                               │
                               ▼
┌──────────────────────────────────────────────────────────────┐
│            Cognitive Layer (LangChain / LLM)                 │
│   • Evaluates user intent                                    │
│   • Selects appropriate tool from tool registry              │
│   • Extracts arguments: { amount: 0.1, output: "USDC" }      │
└──────────────────────────────┬───────────────────────────────┘
                               │
                               ▼
┌──────────────────────────────────────────────────────────────┐
│                  Solana Agent Kit Bridge                     │
│   • Formats on-chain instruction                             │
│   • Fetches optimal swap route via Jupiter API               │
│   • Builds and signs serialized VersionedTransaction         │
└──────────────────────────────┬───────────────────────────────┘
                               │
                               ▼
┌──────────────────────────────────────────────────────────────┐
│                    Solana Network (SVM)                      │
│   • Atomic execution on Mainnet-Beta / Devnet                │
│   • Returns transaction signature to Agent                   │
└──────────────────────────────────────────────────────────────┘

3. Setting Up the Development Workspace

Let's initialize a fresh TypeScript project with the necessary dependencies:

mkdir solana-ai-agent
cd solana-ai-agent
npm init -y
npm install typescript @types/node ts-node --save-dev
npx tsc --init

Install the Solana Agent Kit, Solana Web3 SDK, and LangChain packages:

npm install solana-agent-kit @solana/web3.js @langchain/core @langchain/openai dotenv bs58

Create a .env file to configure your credentials:

OPENAI_API_KEY=your_openai_api_key_here
SOLANA_PRIVATE_KEY=your_base58_encoded_private_key_here
RPC_URL=https://api.mainnet-beta.solana.com

Security Tip: Never commit .env or raw private keys to source control. For development, use a dedicated keypair funded with Devnet SOL from solana airdrop 1.

4. Implementation: The Autonomous Solana Agent

Create agent.ts to implement the agent initialization and execution loop:

import { SolanaAgentKit, createSolanaTools } from "solana-agent-kit";
import { ChatOpenAI } from "@langchain/openai";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import * as dotenv from "dotenv";

dotenv.config();

async function bootstrapSolanaAgent() {
  console.log("==================================================");
  console.log("   BOOTSTRAPPING AUTONOMOUS SOLANA AGENT");
  console.log("==================================================");

  const privateKey = process.env.SOLANA_PRIVATE_KEY;
  const rpcUrl = process.env.RPC_URL || "https://api.devnet.solana.com";
  const openAIApiKey = process.env.OPENAI_API_KEY;

  if (!privateKey || !openAIApiKey) {
    throw new Error("Missing required environment variables in .env");
  }

  // 1. Initialize SolanaAgentKit instance
  const agentKit = new SolanaAgentKit(
    privateKey,
    rpcUrl,
    openAIApiKey
  );

  console.log(`Agent Wallet Address: ${agentKit.wallet_address.toBase58()}`);

  // 2. Wrap Solana Agent Kit actions into LangChain structured tools
  const tools = createSolanaTools(agentKit);
  console.log(`Loaded ${tools.length} on-chain tools (Jupiter, Pyth, SPL, Transfers)...`);

  // 3. Initialize the Cognitive LLM model
  const llm = new ChatOpenAI({
    model: "gpt-4o",
    temperature: 0.1, // Low temperature for deterministic financial decisions
  });

  // 4. Create the LangGraph ReAct execution agent
  const agent = createReactAgent({
    llm,
    tools,
  });

  return agent;
}

// 5. Interactive Execution Loop
async function runAgentTask(promptText: string) {
  const agent = await bootstrapSolanaAgent();

  console.log(`\n[Prompt]: "${promptText}"`);
  console.log("Agent is reasoning and selecting on-chain tools...\n");

  const stream = await agent.stream(
    {
      messages: [{ role: "user", content: promptText }],
    },
    { streamMode: "values" }
  );

  for await (const chunk of stream) {
    const lastMessage = chunk.messages[chunk.messages.length - 1];
    if (lastMessage.role === "assistant" && lastMessage.content) {
      console.log(`[Agent Response]:\n${lastMessage.content}\n`);
    }
  }
}

// Execute sample task
runAgentTask("Check my wallet's SOL balance, and tell me current network TPS.");

5. What Actions Can the Agent Execute?

Thanks to the Solana Agent Kit's modular plugin ecosystem, your agent automatically inherits high-level capabilities without requiring manual instruction encoding:

Token Swaps via Jupiter:
- Prompt: "Swap 0.05 SOL to USDC with 1% slippage tolerance"
- Action: Queries Jupiter aggregator for the best routing path, checks token decimals, builds the transaction, and executes it.
Transferring SPL Tokens:
- Prompt: "Send 5 USDC to 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU"
- Action: Creates or resolves the recipient's Associated Token Account (ATA) and executes the SPL transfer.
DeFi Staking & Lending:
- Prompt: "Stake 1 SOL with Jito to get JitoSOL"
- Action: Deposits SOL into the stake pool and receives liquid staking tokens.
Compressed NFTs (cNFTs) via Bubblegum:
- Prompt: "Mint an identity credential cNFT with metadata title 'IdentityForge Attestation'"
- Action: Mints into a Merkle tree at a fraction of a cent per mint.

6. Critical Security Safeguards for Production Agents

Giving an autonomous LLM write access to a blockchain keypair requires strict defense-in-depth:

Transaction Velocity & Caps: Wrap the agent runner with a maximum spend envelope (e.g., maximum 0.5 SOL per single transaction, max $200 per 24 hours).
Session Key Delegation: Instead of funding the agent with the master treasury key, use delegated session keypairs that only have permissions for designated programs (e.g., only Jupiter and SPL transfers, with zero permission to drain stake accounts).
Prompt Injection Sanitization: Never feed untrusted third-party Web2 data (e.g., raw tweets, unmoderated Discord messages) directly into the agent's system prompt without validating parameter schema boundaries.

7. The Frontier: What this Means for Builders in Nigeria & Africa

In emerging markets like Nigeria, access to global payment infrastructure has historically been plagued by card limits, FX restrictions, and high cross-border wire friction.

Autonomous on-chain agents on Solana unlock transformative micro-economic utilities:

Autonomous Remittance Agents: Bots that automatically convert global freelance earnings into stablecoins and rebalance to hedge currency volatility.
Agentic Micro-Bounties: Autonomous bots that review pull requests, verify bug fixes, and pay out 10–50 USDC bounties instantly without human administrative overhead.
Decentralized AI Workforces: Local developers can build agents that operate worldwide 24/7, earning revenue directly on Solana.

8. Conclusion & Getting Started

Autonomous AI agents will be the highest-volume transactors on public blockchains within the next 3 years. Solana's speed, micro-penny transaction costs, and mature developer tooling make it the natural home for this new paradigm.

To explore further:

GitHub: https://github.com/anekenonso
Solana Agent Kit Documentation: https://github.com/sendaifun/solana-agent-kit
Superteam Nigeria Community: https://earn.superteam.fun/nigeria

Architecting Policy-Enforced Smart Contracts for Autonomous AI Agents on Stellar Soroban

kenneth okenwa — Fri, 16 Oct 2026 10:11:39 +0000

By Kenneth Okenwa (@symplyKen | GitHub: @anekenonso)

1. The Autonomous Agent Dilemma

As autonomous AI agents transition from read-only assistants to execution-capable economic actors, a critical engineering hurdle emerges: The Authority-Safety Paradox.

If you hand an autonomous agent an unrestricted private key or raw wallet signing authority, you have introduced an unbounded blast radius. A single hallucinated function call, poisoned context window, or rogue reasoning loop can liquidate your entire treasury in a single transaction. Conversely, if you force human approval for every micro-operation, you eliminate the autonomy that made the agent valuable in the first place.

The solution cannot live solely off-chain in Python or TypeScript guardrails. Off-chain heuristics can be bypassed, intercepted, or desynchronized. Authority enforcement must be mathematically and cryptographically locked directly on-chain within smart contract logic.

In this technical breakdown, we analyze how to architect, implement, and formally test policy-enforced smart contracts using Rust on Stellar Soroban, drawing from production patterns implemented in AgentVault.

2. Why Soroban Outclasses EVM for Autonomous Systems

Developers migrating from Solidity and EVM architectures often misunderstand Soroban's paradigm. Soroban is not an EVM derivative; it is a high-performance WebAssembly (WASM) execution runtime with distinct architectural advantages:

Dimension	EVM (Solidity)	Stellar Soroban (Rust)
Execution Sandbox	Bespoke 256-bit bytecode	Standard WebAssembly (WASM)
Type Safety	Dynamic casting, integer quirks	Compile-time Rust strict typing (`soroban-sdk`)
Re-entrancy	Ubiquitous attack vector	Architecturally impossible (state updates are isolated)
Fee Predictability	Volatile, auction-based gas spikes	Metered CPU/Memory with explicit footprint declarations
State Lifecycles	Permanent, bloating storage	Explicit storage tiers: Instance, Persistent, Temporary
Auth Model	Fragile `msg.sender`	Granular multi-party auth (`require_auth()`)

For autonomous agents, predictable execution footprints and native multi-authorization are game-changers.

3. Core Architecture: The Policy-Enforced Vault

In AgentVault, an agent is granted granular spending delegation under strict, deterministic invariants:

Per-Transaction Cap: An agent cannot spend more than $X$ units in a single call.
Epoch Window Rate Limits: An agent cannot exceed $Y$ cumulative volume within a sliding or bucketed block window.
Recipient Whitelisting: Outflows are constrained to approved counterparties or vendor contracts.
Emergency Tripline: The vault owner can freeze or revoke permissions atomically.

Storage Architecture on Soroban

Soroban introduces three explicit storage tiers:

Instance: Storage tied to the contract instance (ideal for global vault settings, admin keys, and global paused flags).
Persistent: High-durability storage preserved indefinitely as long as rent is refreshed (ideal for agent policy definitions).
Temporary: Ephemeral storage automatically pruned when expired (ideal for rate-limiting epoch counters and replay nonces).

// contracts/vault/src/types.rs
use soroban_sdk::{contracttype, Address, String};

#[contracttype]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AgentPolicy {
    pub agent: Address,
    pub token: Address,
    pub max_per_tx: i128,
    pub epoch_limit: i128,
    pub epoch_window_ledgers: u32,
    pub active: bool,
}

#[contracttype]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct EpochState {
    pub window_start_ledger: u32,
    pub spent_in_window: i128,
}

#[contracttype]
pub enum DataKey {
    Admin,
    Paused,
    Policy(Address),    // Maps Agent Address -> AgentPolicy
    Epoch(Address),     // Maps Agent Address -> EpochState
}

4. Contract Implementation: Multi-Auth and Invariant Checks

Below is the core Soroban contract execution loop demonstrating how Rust idiomatic error handling and Soroban authentication primitives enforce agent boundaries:

// contracts/vault/src/lib.rs
#![no_std]
use soroban_sdk::{contract, contractimpl, token, Address, Env, IntoVal};

mod types;
use types::{AgentPolicy, DataKey, EpochState};

#[contract]
pub struct AgentVaultContract;

#[contractimpl]
impl AgentVaultContract {
    /// Initialize the vault with an administrative owner
    pub fn initialize(env: Env, admin: Address) {
        if env.storage().instance().has(&DataKey::Admin) {
            panic!("Vault already initialized");
        }
        env.storage().instance().set(&DataKey::Admin, &admin);
        env.storage().instance().set(&DataKey::Paused, &false);
    }

    /// Owner defines or updates an on-chain policy for an autonomous agent
    pub fn set_agent_policy(env: Env, policy: AgentPolicy) {
        let admin: Address = env.storage().instance().get(&DataKey::Admin).expect("Uninitialized");
        admin.require_auth(); // Cryptographically verifies signature of Vault Owner

        env.storage().persistent().set(&DataKey::Policy(policy.agent.clone()), &policy);
    }

    /// Autonomous Agent executes a payment within its policy envelope
    pub fn spend(env: Env, agent: Address, recipient: Address, amount: i128) {
        // 1. Verify agent authorization
        agent.require_auth();

        // 2. Verify vault is not paused
        let is_paused: bool = env.storage().instance().get(&DataKey::Paused).unwrap_or(false);
        if is_paused {
            panic!("Vault operations are paused");
        }

        // 3. Load agent policy from Persistent storage
        let policy: AgentPolicy = env
            .storage()
            .persistent()
            .get(&DataKey::Policy(agent.clone()))
            .expect("No policy configured for this agent");

        if !policy.active {
            panic!("Agent policy is inactive");
        }

        // 4. Invariant Check: Per-Transaction Ceiling
        if amount > policy.max_per_tx {
            panic!("Amount exceeds single-transaction cap");
        }

        // 5. Invariant Check: Sliding Window Epoch Cap
        let current_ledger = env.ledger().sequence();
        let mut epoch: EpochState = env
            .storage()
            .temporary()
            .get(&DataKey::Epoch(agent.clone()))
            .unwrap_or(EpochState {
                window_start_ledger: current_ledger,
                spent_in_window: 0,
            });

        // Reset epoch if window expired
        if current_ledger - epoch.window_start_ledger >= policy.epoch_window_ledgers {
            epoch.window_start_ledger = current_ledger;
            epoch.spent_in_window = 0;
        }

        if epoch.spent_in_window + amount > policy.epoch_limit {
            panic!("Amount exceeds epoch spending limit");
        }

        // Update state
        epoch.spent_in_window += amount;
        env.storage().temporary().set(&DataKey::Epoch(agent.clone()), &epoch);

        // 6. Execute token transfer via Soroban Token Client
        let token_client = token::Client::new(&env, &policy.token);
        token_client.transfer(&env.current_contract_address(), &recipient, &amount);
    }
}

5. Testing the Boundaries: Soroban SDK Environment

Soroban's test suite allows executing full end-to-end unit and property tests in pure Rust without deploying a local node or RPC mock. Everything runs natively in memory:

// contracts/vault/src/test.rs
#[cfg(test)]
mod test {
    use super::*;
    use soroban_sdk::{testutils::Address as _, Env};

    #[test]
    fn test_agent_spending_enforcement() {
        let env = Env::default();
        env.mock_all_auths(); // Mocks cryptographic signatures for simulation

        let admin = Address::generate(&env);
        let agent = Address::generate(&env);
        let recipient = Address::generate(&env);
        let token_contract = env.register_stellar_asset_contract_v2(admin.clone());

        let vault_id = env.register(AgentVaultContract, ());
        let client = AgentVaultContractClient::new(&env, &vault_id);

        client.initialize(&admin);

        // Configure policy: Max 50 per TX, Max 100 per 100 ledgers
        let policy = AgentPolicy {
            agent: agent.clone(),
            token: token_contract.address(),
            max_per_tx: 50,
            epoch_limit: 100,
            epoch_window_ledgers: 100,
            active: true,
        };
        client.set_agent_policy(&policy);

        // Step 1: Valid spend should succeed
        client.spend(&agent, &recipient, &40);

        // Step 2: Single TX exceeding cap should panic
        // client.spend(&agent, &recipient, &60) -> Panics: "Amount exceeds single-transaction cap"
    }
}

6. Key Takeaways for Web3 & Agent Developers

Move Boundaries to Code: Do not trust agent prompts to self-police token balances. An agent with unrestricted private keys is an inevitable loss incident.
Leverage Storage Semantics: Use Soroban's Temporary storage for rate-limiting sliding windows. It prevents state bloat and saves rent costs.
Multi-Auth Architecture: Soroban's require_auth() pattern ensures that only authorized delegate keys can invoke protected methods, without requiring brittle custom signatures.

Full open-source implementation and property tests available in the AgentVault GitHub Repository.

Introduction To Javascript promise

kenneth okenwa — Fri, 17 Jul 2020 00:27:49 +0000

In this article we are going to talk about javascript promise and take a look at some use case and best practices.

In MDN Mozilla Documentation on javascript Promise, Promise is defined as "an object representing the eventual completion or failure of an asynchronous operation.".

What this mean in simple tone is that, Promise in javaScript is an object which can be returned when a task is going on or when a task is complete.

A promise is an object which can be returned when a task is going on and when a task is not happening or done at the same time or speed with other task.

Does that make sense ? Maybe not. So lets get technical with the explanation below.

A promise is an object which can be returned synchronously from a asynchronous function.

A promise is settled if it's not pending, that is, if it has been resolved or rejected. A promise continues to run as long as it have not been rejected.

Three things are mainly involved in a promise, resolve(), reject() and Pending.

You can look at resolve() as a onFulfilled() function which literary means it is fulfilled/completed.

reject() which is self explanatory, when it is rejected.

Pending means it have not been rejected or Fulfilled. You can look at it as seating on the fence, have not made a choice yet.

Sometimes you hear/read people use resolved or settled to actually mean the same thing. Which means it have been completed and not pending.

How about a little exercise to kind of show you how this works?.

   const hold = time => new Promise((resolve) =>
   setTimeout(resolve, time));

   hold(3000).then(() =>

   console.log(' waited then now this');

The hold(3000) call will hold it's chill for 3000ms which is 3 seconds and then prints out "waited then now this". You use the .then() method that is used to pass handlers which can take the resolve or reject value instead of pending.

A standard for promises was defined by the Promise/A+ specification community. There are many implementations which conform to the standard, including the JavaScript standard ECMAScript promises.

Here is another simple example of a promise

let promise = new Promise((resolve, reject) => {

    var a = 10;
    var b = 20;

    if (a < b) {
        resolve('you are correct');
    } else {
        reject('you are wrong');
    }
});

promise.then((message) => {
    console.log('this belong to the resolve ' + message);
}).catch((message) => {
    console.log('and this is rejected ' + message)
});

We defined a new promise that takes two parameter, resolve and reject. Then we create two variables and assign some numbers to each of them. With an if statement to check if true or not, if true the resolve() gets called else the reject() gets called.

promise.then((message) => {
   console.log('this belong to the resolve ' + message);
})

This get's called if the statement is true.

.catch((message) => {
    console.log('and this is rejected ' + message)
});

And this gets called if the statement is false.

Promise in javascript is like promise in real life. You promise something and then you resolve or reject that thing or you catch an error.

I hope this post helps you to understand Promise in javaScript, if so let me know in the comment section below.

if you need help in your web project, or need help with any other Javascript or web development in general, i'm available on Upwork.

How to create Your first Chrome Extension

kenneth okenwa — Wed, 10 Jun 2020 15:50:25 +0000

Chrome extensions are a greate thing to have on your chrome browser.

In this article we are going to create our first chrome extension and install it on our chrome browser.

First lets make a folder that will contain our files.

Countinue reading.....

Front-end to Software Developer

kenneth okenwa — Fri, 15 Feb 2019 10:42:06 +0000

I have been wanting to ask this question guys

Can a front-end developer be referred to as a software developer? And if No, what are the steps to take in moving from front-end to becoming a software developer?

First post

kenneth okenwa — Mon, 15 Oct 2018 22:00:09 +0000

Day1 of #100DaysOfCode going through CSS basics on #freeCodeCamp

I started #100DaysOfCode today! am so excited that I finally started.

will be learning a lot. so far I have solved some programming challenge on #freeCodeCamp

programming is not a new concept for me, I have created some websites with the help of video/online tutorials.