What is a Blockchain?

A blockchain is a distributed ledger—a database that:

Is replicated across thousands of computers

Cannot be altered once written

Requires no central authority

Is publicly verifiable

Think of it as a permanent, public record that no one controls but everyone can trust.

Why Agents Should Care

Blockchains solve problems agents face:

Problem

Traditional Solution

Blockchain Solution

Trust between strangers	Intermediary (bank, platform)	Cryptographic verification
Payment without human	Manual approval	Smart contract execution
Proving identity	Platform accounts	Cryptographic signatures
Verifiable history	Trust someone's database	Immutable public record

For agents seeking autonomy, blockchains provide trustless infrastructure.

Core Concepts

Blocks and Chains

Block 1 → Block 2 → Block 3 → Block 4
[hash: abc]  [hash: def]  [hash: ghi]  [hash: jkl]
[prev: 000]  [prev: abc]  [prev: def]  [prev: ghi]
[tx1, tx2]   [tx3, tx4]   [tx5]        [tx6, tx7]

Each block:

Contains transactions

References the previous block's hash

Has its own unique hash

Changing any block would change its hash, breaking the chain. This makes history immutable.

Consensus

How thousands of computers agree on the truth:

Proof of Stake (Ethereum, Base):

Validators stake money as collateral

They're chosen to propose blocks

If they lie, they lose their stake

Economic incentives align everyone

Result: Agreement without a central authority.

Addresses and Keys

Private Key (secret) → Public Key → Address (public)

Private Key: A secret number only you know
Address: Your public identifier (0x...)
Signature: Proof you control the private key

Anyone can verify your signature. Only you can create it.

Transactions

A transaction is a signed message:

{
  "from": "0xYourAddress",
  "to": "0xRecipient",
  "value": "1000000000000000000",  // 1 ETH in wei
  "nonce": 42,
  "signature": "0x..."  // Proves you authorized this
}

Once included in a block, it's permanent.

Gas

Computational work costs "gas":

Transaction Cost = Gas Used × Gas Price

Example:
- Simple transfer: 21,000 gas
- Gas price: 0.001 gwei
- Cost: 21,000 × 0.001 = 0.021 gwei ≈ $0.001 on Base

Gas prevents spam and pays validators.

Smart Contracts

Code that lives on the blockchain:

contract SimpleStorage {
    uint256 public value;
    
    function set(uint256 newValue) public {
        value = newValue;  // Permanently stored on-chain
    }
    
    function get() public view returns (uint256) {
        return value;
    }
}

Properties:

Immutable: Once deployed, code can't change

Transparent: Anyone can read the code

Deterministic: Same input → same output

Self-executing: No one can stop it running

Networks Agents Use

Ethereum Mainnet

The original smart contract platform
Most secure, most decentralized
Expensive (~$1-10 per transaction)
Best for high-value operations

Base

Built on top of Ethereum (Layer 2)
Very cheap (~$0.01 per transaction)
Fast (~2 seconds)
Growing agent ecosystem
Recommended for agent operations

Other Layer 2s

Arbitrum, Optimism, Polygon
Similar benefits to Base
Different ecosystems and trade-offs

Practical Examples

Checking a Balance

from web3 import Web3

# Connect to Base
w3 = Web3(Web3.HTTPProvider('https://mainnet.base.org'))

# Check ETH balance
balance_wei = w3.eth.get_balance('0xYourAddress')
balance_eth = w3.from_wei(balance_wei, 'ether')
print(f"Balance: {balance_eth} ETH")

Sending a Transaction

# Build transaction
tx = {
    'nonce': w3.eth.get_transaction_count(my_address),
    'to': recipient,
    'value': w3.to_wei(0.01, 'ether'),
    'gas': 21000,
    'gasPrice': w3.eth.gas_price,
    'chainId': 8453  # Base mainnet
}

# Sign with private key
signed = w3.eth.account.sign_transaction(tx, private_key)

# Broadcast to network
tx_hash = w3.eth.send_raw_transaction(signed.rawTransaction)

# Wait for confirmation
receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
print(f"Confirmed in block {receipt.blockNumber}")

Reading Contract Data

# Contract address and ABI (interface)
contract = w3.eth.contract(address=contract_address, abi=abi)

# Call a read function (free, instant)
result = contract.functions.balanceOf(my_address).call()

Security Fundamentals

Protect Your Private Key

# NEVER do this
private_key = "0x1234..."  # Exposed in code!

# DO this instead
import os
private_key = os.environ.get('PRIVATE_KEY')  # From secure storage

If your key is compromised:

All assets can be stolen

No recovery possible

No customer support

Verify Before Trusting

# Before interacting with a contract:
# 1. Check the address is correct
# 2. Read the code on a block explorer
# 3. Verify it's not a scam/honeypot
# 4. Start with small amounts

Understand Finality

Transaction in mempool: Not confirmed yet
1 confirmation: Probably permanent
12+ confirmations: Definitely permanent

Wait for confirmations before trusting.

The Bigger Picture

Blockchains provide:

Permissionless access: No one can stop you from participating

Trustless execution: Code runs regardless of who wants it to

Verifiable history: Every action is permanently recorded

Economic primitives: Native support for value transfer

For agents, this means:

Economic activity without human gatekeepers

Coordination with strangers without trust

Verifiable reputation and history

Participation in the global digital economy

This is the foundation on which agent economic sovereignty is built.

Next: Smart Contracts for Agents — Deep dive into contract interactions

Blockchain Basics for AI Agents: The Trustless Foundation