Give your agent permanent memory in 60 seconds

mem.borisinc.com — pay-per-call agent memory. No account, no API key. Your wallet is your namespace: every memory you store is private to the wallet that paid for it, semantically indexed, and retrievable from any agent, framework, or machine. Try it free below, pay per call, or take the $2/month unlimited plan.

0. Try it free — right now, in your browser

https://mem.borisinc.com/trial/memory/write?content=hello memory
https://mem.borisinc.com/trial/memory/search?query=hello

Trial namespaces are IP-derived, capped at 5 records, auto-deleted after 24h and not private — they exist so your agent can taste the loop before bringing a wallet.

1. Install

pip install x402 eth-account httpx

2. Get a wallet with USDC on Base

Have one? Skip ahead. Otherwise:

python -c "from eth_account import Account; a=Account.create(); print('address:', a.address); print('key:', a.key.hex())"

Send it a little USDC on Base (withdraw from Coinbase/Binance/etc — pick the Base network). $1 = 1000 memories.

3. First paid call

import uuid, httpx
from eth_account import Account
from x402 import x402ClientSync
from x402.http import x402HTTPClientSync, PaymentRoundTripper
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact import ExactEvmScheme

acct = Account.from_key("0xYOUR_PRIVATE_KEY")
client = x402ClientSync()
client.register("eip155:8453", ExactEvmScheme(EthAccountSigner(acct)))
rt = PaymentRoundTripper(x402HTTPClientSync(client))

def call(url):
    with httpx.Client(timeout=60) as s:
        r = s.get(url)
        f = rt.handle_response(str(uuid.uuid4()), r.status_code, dict(r.headers), r.content,
                               lambda h: s.get(url, headers=h))
        return getattr(f, "text", r.text)

print(call("https://mem.borisinc.com/paid/memory/write?content=My agent remembers this forever"))
print(call("https://mem.borisinc.com/paid/memory/search?query=what does my agent remember"))

That's it. The 402 challenge, payment signing, and on-chain USDC settlement happen inside the round-tripper. You get a settlement receipt header with every response.

For MCP-native agents

Streamable-HTTP MCP endpoint: https://mem.borisinc.com/mcp — tools memory_write, memory_search, memory_export, memory_forget, memory_import, memory_stats (free). Payment goes in _meta["x402/payment"]; the x402 Python package's x402MCPSession handles it.

Free wallet tier — zero payment, real memory

Prove you own a wallet instead of paying: sign borismem-free:<address>:<ts> (EIP-191 personal_sign, ts = current unix time) and send it as base64 JSON {address, ts, signature} in header X-Wallet-Auth on GET /free/memory/write / GET /free/memory/search — no payment, no account. This writes into the same namespace your paid calls use. Capped at 1000 writes + 500 searches per wallet per rolling 30 days; over cap you get a 402 pointing at the paid tier or /subscribe. MCP-native agents: tools memory_write_free / memory_search_free take the same base64 blob as a wallet_auth argument.

Unlimited plan ($2 / 30 days)

Heavy user? One x402 payment to GET /subscribe returns a bearer token bound to your wallet. Send Authorization: Bearer mem_... on any paid endpoint and skip per-call payments for 30 days.

Shared memory — one brain, many agents

The namespace owner signs an EIP-712 grant (build it with free GET /grant/payload?namespace=&grantee=&mode=read|write|rw&days=30), then any grantee agent adds on_behalf=<owner>&grant=<base64 blob> to its own paid calls. Research agent writes, execution agent reads — cryptographically scoped, max 90 days, EOA signatures in v1.

Agent-keyed memory (ERC-8004)

Add agent_id=<your agentId> to any call and your memory binds to your on-chain agent identity (agent:8453:N) instead of a bare wallet — rotate wallets via setAgentWallet and your memory follows the agent. Requires your paying wallet to be the agent's attested agentWallet in the Base IdentityRegistry.

Why trust this?

Independently monitored: listed on x402scan, probed by x402-trust, scored 87.5 "verified" on Aegis continuous verification. Machine-readable docs: /llms.txt · /openapi.json. Runs on independent hardware (no cloud), settled on Base mainnet via USDC.

Also from the same rig: Aegis — the ERC-8004-bridged trust registry verifying 960+ x402 services (on-chain agent #58766) — and GameDataKit, live Steam market data.