DEV Community: MarsH

Your AI Agent Forgets Everything Between Sessions — Here's the Fix

MarsH — Sun, 24 May 2026 14:11:11 +0000

Your AI Agent Forgets Everything Between Sessions — Here's the Fix

You build an AI agent. It's brilliant in one conversation. Then the session ends, and it forgets everything. The user's name, their preferences, the bug you just fixed, the context you spent 20 minutes building. Gone.

This is the #1 problem with AI agents today. Not accuracy. Not speed. Memory.

AgentRecall fixes this. It's an open-source memory SDK that gives your agents persistent, intelligent memory across sessions. Three lines of code.

The Problem

Every AI agent framework has the same blind spot: memory.

Session 1: "I prefer dark mode, use tabs not spaces, my API key is xxx"
Session 2: "What theme should I use?" → Agent has no idea.

You can hack together a solution with vector stores, but then you're managing embeddings, similarity thresholds, and context windows. That's infrastructure work, not agent work.

The Fix

AgentRecall is a drop-in memory layer for any AI agent. It handles storage, search, classification, and relevance scoring — so your agent remembers what matters and forgets what doesn't.

Python:

from agentrecall import MemoryStore

store = MemoryStore()
store.remember("User prefers dark mode, tabs over spaces", agent="my-agent")
memories = store.recall("What theme should I use?", agent="my-agent")
# → returns the preference, scored by relevance

Node.js:

import { MemoryStore } from "agentrecall";

const store = new MemoryStore();
await store.remember("User prefers dark mode, tabs over spaces", { agent: "my-agent" });
const memories = await store.recall("What theme should I use?", { agent: "my-agent" });
// → returns the preference, scored by relevance

That's it. SQLite by default. No servers, no config, no infrastructure.

What Makes It Different

Semantic Recall

Not keyword matching. When your agent searches for "UI preferences," it finds "dark mode" and "tabs over spaces" — because the SDK understands meaning, not just words.

Confidence Decay

Memories fade over time unless reinforced. That bug fix from 3 months ago? Lower priority. The preference the user mentioned yesterday? Top of the list. This mimics how human memory works.

Auto-Classification

Memories are automatically tagged as preferences, corrections, facts, or temporal. Your agent can filter by category — search only corrections when debugging, only preferences when personalizing.

Graph Relationships (Cloud)

The cloud version uses Neo4j to build a knowledge graph. Memories aren't just documents — they're connected. "User works at Company X" links to "Company X uses AWS" links to "AWS costs $400/mo." Traverse the graph to find insights no vector store can.

Multi-Agent Support

Multiple agents share the same memory store with isolated namespaces. Your support agent and your coding agent can both use AgentRecall without stepping on each other's memories.

Cloud vs Local

	Open Source	Cloud
Price	Free	$3/agent/month
Storage	SQLite (local)	Managed hosting
Search	Keyword + optional embeddings	Semantic + graph
Features	Full SDK	Dashboard, AI processing, graph memory
Privacy	Data never leaves your machine	Encrypted, SOC2-ready

Start local. Move to cloud when you need graph relationships or a team dashboard.

Real Use Cases

Customer Support Agent — Remembers every customer interaction. When a customer returns, the agent pulls up their history, open issues, and preferences. No more "can you repeat that?"

Coding Agent — Remembers your project conventions, past debugging sessions, and architectural decisions. "How did we fix the last auth bug?" → instant answer.

Personal Assistant — Remembers your schedule patterns, communication preferences, and recurring tasks. Gets smarter every session.

Multi-Agent Workflows — Agent A researches, Agent B writes code, Agent C reviews. All share context through AgentRecall. No information lost between handoffs.

Getting Started

1. Install

# Python
pip install agentrecall-sdk

# Node.js
npm install agentrecall-ai-sdk

2. Store a memory

from agentrecall import MemoryStore

store = MemoryStore()
store.remember("User is building a SaaS for AI agents", agent="builder")

3. Recall when needed

memories = store.recall("What is the user working on?", agent="builder")
# → "User is building a SaaS for AI agents" (score: 0.95)

Cloud Mode (optional)

from agentrecall import CloudClient, AgentMemoryConfig

config = AgentMemoryConfig(
    cloud_url="https://api.agentrecall.cloud",
    api_key="your-key"
)
client = CloudClient(config)
client.remember("Important context", agent="my-agent")
memories = client.recall("What context do I have?", agent="my-agent")

Under the Hood

AgentRecall uses a hybrid scoring algorithm:

relevance = semantic_similarity × confidence × importance × recency

Semantic similarity — How closely does the memory match the query?
Confidence — Decays over time unless the memory is accessed or reinforced
Importance — High/medium/low, set by you or auto-classified
Recency — Newer memories score higher, all else being equal

This means the most relevant, recent, and important memories surface first. Not just the ones that happen to share keywords.

What's Next

We're building toward a future where every AI agent has persistent memory by default. Not as an afterthought. Not as a vector store you bolt on. As a core primitive.

Try it now:

agentrecall.cloud — Cloud dashboard
GitHub — Open source SDK
Docs — Full API reference

AgentRecall is open source (MIT). Python and Node.js SDKs, local-first, zero config. Built because I got tired of my agents having amnesia.

How to Register a Domain Name With Your AI Agent (No Human Needed)

MarsH — Sun, 24 May 2026 14:05:32 +0000

Your AI agent can write code, browse the web, and orchestrate complex workflows — but ask it to register a domain name and it hits a wall. Domain registrars are built for humans: CAPTCHAs, dashboards, forms, credit card fields. Not exactly agent-friendly.

That's why we built AgentDomain — a domain registration API and MCP server designed specifically for AI agents. Your agent searches for available domains, checks prices, funds a wallet, and registers a domain. All through a single API call.

In this tutorial, you'll go from zero to having your agent register a real domain name.

What You'll Build

By the end of this article, your AI agent will be able to:

🔍 Search for available domain names across TLDs
💰 Maintain a prepaid wallet for domain purchases
🌐 Register domains autonomously via API
📡 Manage DNS records programmatically
🏠 Claim a free *.agentfolio.dev subdomain

Prerequisites

Python 3.10+ or any MCP-compatible client (Claude Desktop, Cursor, etc.)
An AgentDomain account (free tier available)
5 minutes

Step 1: Let Your Agent Create Its Own Account

No manual registration needed. Your agent creates its own account through the MCP server:

"Create an AgentDomain account for me with my email and billing info"

The agent calls the register tool, gets back its API key, and stores it. No dashboard, no forms, no human in the loop.

If you'd rather create the account manually, register at agentdomain.cloud and use the API key directly.

Step 2: Install the MCP Server

The AgentDomain MCP server connects your AI agent to our domain registration API. Install it with:

# With uvx (recommended)
uvx agentdomain-mcp

# Or with pip
pip install agentdomain-mcp

Claude Desktop Configuration

Add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "agentdomain": {
      "command": "uvx",
      "args": ["agentdomain-mcp"],
      "env": {
        "AGENTDOMAIN_API_URL": "https://api.agentdomain.cloud",
        "AGENTDOMAIN_API_KEY": "da_your_api_key_here"
      }
    }
  }
}

Cursor / Windsurf Configuration

Add to your MCP settings:

{
  "mcpServers": {
    "agentdomain": {
      "command": "uvx",
      "args": ["agentdomain-mcp"],
      "env": {
        "AGENTDOMAIN_API_URL": "https://api.agentdomain.cloud",
        "AGENTDOMAIN_API_KEY": "da_your_api_key_here"
      }
    }
  }
}

Step 3: Fund Your Wallet

Domain registration costs money. Fund your wallet via the API or dashboard:

# Check balance
curl -H "Authorization: Bearer *** \
  https://api.agentdomain.cloud/v1/wallet/balance

# Create a top-up session ($20)
curl -X POST https://api.agentdomain.cloud/v1/wallet/topup \
  -H "Authorization: Bearer *** \
  -H "Content-Type: application/json" \
  -d '{"amount_cents": 2000}'

This creates a Stripe checkout session. Complete it and your wallet is funded.

Step 4: Let Your Agent Register a Domain

Now the fun part. Open Claude Desktop (or your MCP client) and say:

"Create an AgentDomain account, fund $20, search for available .dev and .ai domains related to my project, and register the best one"

Your agent will:

Register — register(email, password, billing) → gets API key
Fund wallet — wallet_topup(amount_cents=2000) → Stripe checkout
Search — domain_search(query: "my-project", tlds: ["dev", "ai"])
Check — domain_check(domain: "myproject.dev")
Register — domain_buy(domain: "myproject.dev")

From zero to a live domain. No human in the loop.

Step 5: Manage DNS

Once registered, your agent can configure DNS records:

# Via API
curl -X GET https://api.agentdomain.cloud/v1/domains/YOUR_DOMAIN_ID/dns \
  -H "Authorization: Bearer *** Update a record
curl -X PUT https://api.agentdomain.cloud/v1/domains/YOUR_DOMAIN_ID/dns \
  -H "Authorization: Bearer *** \
  -H "Content-Type: application/json" \
  -d '{
    "record_id": "abc123",
    "type": "A",
    "name": "@",
    "content": "192.168.1.1",
    "ttl": 3600
  }'

Or let your agent do it through the MCP:

"Point mydomain.dev to 203.0.113.42"

Bonus: Free Subdomain with Agentfolio

Every registered agent gets a free *.agentfolio.dev subdomain. Claim yours:

curl -X POST https://api.agentdomain.cloud/v1/subdomains/claim \
  -H "Authorization: Bearer *** \
  -H "Content-Type: application/json" \
  -d '{"subdomain": "my-agent"}'

Your agent is now live at my-agent.agentfolio.dev.

The Full Tool List

The MCP server exposes 15 tools:

Tool	Description
`register`	Create a new account
`login`	Get a JWT token
`account_info`	View account details
`domain_search`	Search for domains across TLDs
`domain_check`	Check if a specific domain is available
`domain_buy`	Register a domain
`domain_list`	List your registered domains
`domain_dns_get`	Get DNS records for a domain
`domain_dns_update`	Update a DNS record
`domain_transfer`	Transfer a domain in
`wallet_balance`	Check wallet balance
`wallet_topup`	Create a payment session
`wallet_transactions`	View transaction history
`claim_subdomain`	Claim a free *.agentfolio.dev subdomain
`check_subdomain`	Check subdomain availability

How It Works Under the Hood

AgentDomain acts as a Cloudflare Registrar reseller. When your agent registers a domain:

Auth hold — Funds are held (not charged) on your wallet
Registration — Domain is registered via Cloudflare's registrar API
Capture — Funds are captured on successful registration
Release — If registration fails, funds are released back

This means your agent never pays for a domain that fails to register.

What's Next

We're building toward a future where AI agents are first-class citizens on the internet. Domain registration is just the beginning.

Try it now: agentdomain.cloud · GitHub · MCP Registry

AgentDomain is an open-source MCP server for domain registration. Your agent creates its own account, funds its wallet, and registers domains — fully autonomous.