autonomous ai agentsagentic memoryai workflowsllm agentsagent architectureagents memory typesbusiness automation

Building Autonomous AI Agents: Memory Systems Guide

Usama Amjid
10 min read
8976 words
Building Autonomous AI Agents: Memory Systems Guide

Introduction

You've deployed your first AI agent, but it keeps asking users the same questions. Your autonomous workflow fails halfway through and restarts from scratch. Your business automation forgets customer preferences between sessions.

This isn't just frustrating—it's the difference between a chatbot and a truly autonomous AI agent that can handle real business workflows.

Autonomous AI agents need memory to function effectively. Without it, they can't maintain context, learn from interactions, or complete multi-step workflows. In this guide, you'll learn the five types of agentic memory, how to architect production-ready memory systems, and functional TypeScript implementations you can deploy today.

Whether you're building customer service automation, sales workflows, or complex business process agents, mastering agentic memory is essential for creating truly autonomous systems that deliver real business value.

Understanding Autonomous AI Agents and Memory Systems

Autonomous AI agents differ from simple chatbots in one critical way: they can complete complex workflows independently without constant human guidance. But autonomy requires memory.

Think about a sales agent that qualifies leads. It needs to:

  • •Remember previous conversations with prospects
  • •Track where each prospect is in the sales funnel
  • •Recall preferences and objections raised earlier
  • •Maintain state across multiple touchpoints
  • •Learn from successful and failed interactions

This requires sophisticated memory systems that go far beyond passing chat history to an LLM.

What Makes AI Agents Truly Autonomous

Autonomous agents exhibit three key characteristics:

Goal-directed behavior: They work toward objectives without step-by-step instructions. A customer support agent aims to resolve issues, not just answer questions.

Stateful operation: They remember context and maintain workflow state across sessions. An onboarding agent picks up where it left off, even if interrupted.

Adaptive learning: They improve based on outcomes and feedback. A sales agent adjusts its approach based on what works.

All three depend on robust memory systems. Without memory, agents are stateless responders, not autonomous workers.

The Five Types of Agentic Memory

Modern autonomous AI agents implement five distinct memory types. Each serves a specific purpose in enabling true autonomy.

1. Working Memory (Short-Term Context)

This is the agent's immediate awareness—the current conversation or task context. It lives in the prompt and is limited by the model's context window.

typescript
import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage, AIMessage, SystemMessage } from "@langchain/core/messages";

interface ConversationMessage {
  role: 'user' | 'assistant' | 'system';
  content: string;
  timestamp: Date;
}

async function maintainWorkingMemory(
  messages: ConversationMessage[],
  newUserMessage: string
): Promise<string> {
  const llm = new ChatOpenAI({ 
    modelName: "gpt-4-turbo",
    temperature: 0.7 
  });

  // Keep last 10 messages for working memory
  const recentMessages = messages.slice(-10);
  
  const formattedMessages = [
    new SystemMessage("You are an autonomous business workflow agent."),
    ...recentMessages.map(msg => 
      msg.role === 'user' 
        ? new HumanMessage(msg.content)
        : new AIMessage(msg.content)
    ),
    new HumanMessage(newUserMessage)
  ];

  const response = await llm.invoke(formattedMessages);
  return response.content as string;
}

Use case: Following the current conversation thread, maintaining context for the immediate task.

Limitation: Disappears when the conversation ends. Not suitable for long-term learning or cross-session continuity.

2. Episodic Memory (Interaction History)

Episodic memory stores specific past interactions. Your agent recalls "what happened" in previous conversations with this user.

typescript
import { OpenAIEmbeddings } from "@langchain/openai";
import { PineconeStore } from "@langchain/pinecone";
import { Document } from "@langchain/core/documents";

interface Episode {
  userId: string;
  interaction: string;
  outcome: 'success' | 'failure' | 'neutral';
  timestamp: Date;
  metadata: Record<string, any>;
}

async function storeEpisode(
  vectorStore: PineconeStore,
  episode: Episode
): Promise<void> {
  const document = new Document({
    pageContent: episode.interaction,
    metadata: {
      userId: episode.userId,
      outcome: episode.outcome,
      timestamp: episode.timestamp.toISOString(),
      ...episode.metadata
    }
  });

  await vectorStore.addDocuments([document]);
}

async function recallRelevantEpisodes(
  vectorStore: PineconeStore,
  userId: string,
  currentContext: string,
  limit: number = 5
): Promise<Episode[]> {
  const results = await vectorStore.similaritySearch(
    currentContext,
    limit,
    { userId } // Filter by user
  );

  return results.map(doc => ({
    userId: doc.metadata.userId,
    interaction: doc.pageContent,
    outcome: doc.metadata.outcome,
    timestamp: new Date(doc.metadata.timestamp),
    metadata: doc.metadata
  }));
}

Use case: Personalizing responses based on conversation history, avoiding repeated questions, building rapport.

Why autonomous agents need this: They can adapt their approach based on what worked or failed in previous interactions with the same user.

3. Semantic Memory (Knowledge Base)

Semantic memory represents what the agent "knows"—domain knowledge, company policies, product information, and procedures.

typescript
import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";

interface KnowledgeDocument {
  content: string;
  source: string;
  category: string;
  lastUpdated: Date;
}

async function buildSemanticMemory(
  vectorStore: PineconeStore,
  documents: KnowledgeDocument[]
): Promise<void> {
  const textSplitter = new RecursiveCharacterTextSplitter({
    chunkSize: 1000,
    chunkOverlap: 200,
  });

  for (const doc of documents) {
    const chunks = await textSplitter.createDocuments(
      [doc.content],
      [{
        source: doc.source,
        category: doc.category,
        lastUpdated: doc.lastUpdated.toISOString()
      }]
    );

    await vectorStore.addDocuments(chunks);
  }
}

async function queryKnowledge(
  vectorStore: PineconeStore,
  question: string,
  category?: string
): Promise<string[]> {
  const filter = category ? { category } : undefined;
  
  const results = await vectorStore.similaritySearch(
    question,
    3,
    filter
  );

  return results.map(doc => doc.pageContent);
}

Use case: Answering questions about products, following company policies, executing standard procedures.

Autonomous agent advantage: Agents can operate independently because they have access to institutional knowledge without human lookup.

4. Procedural Memory (Workflow State)

Procedural memory tracks how to do things and where the agent is in multi-step processes. This is critical for autonomous workflow execution.

typescript
interface WorkflowState {
  workflowId: string;
  currentStep: string;
  completedSteps: string[];
  pendingActions: Action[];
  collectedData: Record<string, any>;
  startedAt: Date;
  lastUpdated: Date;
}

interface Action {
  id: string;
  type: string;
  status: 'pending' | 'in_progress' | 'completed' | 'failed';
  data: any;
}

async function saveWorkflowState(
  stateStore: any, // Redis, PostgreSQL, etc.
  state: WorkflowState
): Promise<void> {
  const key = `workflow:${state.workflowId}`;
  const ttl = 86400; // 24 hours
  
  await stateStore.setex(
    key,
    ttl,
    JSON.stringify({
      ...state,
      lastUpdated: new Date()
    })
  );
}

async function loadWorkflowState(
  stateStore: any,
  workflowId: string
): Promise<WorkflowState | null> {
  const key = `workflow:${workflowId}`;
  const data = await stateStore.get(key);
  
  if (!data) return null;
  
  const state = JSON.parse(data);
  return {
    ...state,
    startedAt: new Date(state.startedAt),
    lastUpdated: new Date(state.lastUpdated)
  };
}

async function progressWorkflow(
  stateStore: any,
  workflowId: string,
  completedStep: string,
  nextStep: string,
  collectedData?: Record<string, any>
): Promise<WorkflowState> {
  const currentState = await loadWorkflowState(stateStore, workflowId);
  
  if (!currentState) {
    throw new Error(`Workflow ${workflowId} not found`);
  }

  const updatedState: WorkflowState = {
    ...currentState,
    currentStep: nextStep,
    completedSteps: [...currentState.completedSteps, completedStep],
    collectedData: { ...currentState.collectedData, ...collectedData }
  };

  await saveWorkflowState(stateStore, updatedState);
  return updatedState;
}

Use case: Multi-step business processes like onboarding, KYC verification, order fulfillment, support ticket resolution.

Critical for autonomy: The agent can pause, resume, and recover from failures without losing progress.

5. Meta-Memory (Learning and Adaptation)

Meta-memory is memory about memory—the agent learns which strategies work and adapts its behavior over time.

typescript
interface StrategyOutcome {
  strategyId: string;
  context: string;
  outcome: 'success' | 'failure';
  metrics: {
    userSatisfaction?: number;
    taskCompletion?: boolean;
    timeToResolution?: number;
  };
  timestamp: Date;
}

async function recordStrategyOutcome(
  database: any,
  outcome: StrategyOutcome
): Promise<void> {
  await database.insert('strategy_outcomes', {
    strategy_id: outcome.strategyId,
    context: outcome.context,
    outcome: outcome.outcome,
    metrics: JSON.stringify(outcome.metrics),
    timestamp: outcome.timestamp
  });
}

async function selectBestStrategy(
  database: any,
  currentContext: string,
  availableStrategies: string[]
): Promise<string> {
  // Query historical success rates for similar contexts
  const results = await database.query(`
    SELECT 
      strategy_id,
      COUNT(*) as total_uses,
      SUM(CASE WHEN outcome = 'success' THEN 1 ELSE 0 END) as successes,
      AVG(CASE WHEN outcome = 'success' THEN 1 ELSE 0 END) as success_rate
    FROM strategy_outcomes
    WHERE strategy_id IN (${availableStrategies.map(() => '?').join(',')})
      AND context SIMILAR TO ?
    GROUP BY strategy_id
    ORDER BY success_rate DESC, total_uses DESC
    LIMIT 1
  `, [...availableStrategies, `%${currentContext}%`]);

  return results[0]?.strategy_id || availableStrategies[0];
}

Use case: Improving agent performance over time, A/B testing different approaches, adaptive customer communication styles.

Autonomous learning: The agent becomes more effective without explicit programming or human intervention.

Architectural Patterns for Autonomous Agent Memory

Let's explore production-ready architectures that combine these memory types.

Pattern 1: Hybrid Memory Architecture for Business Workflows

This pattern combines vector search for semantic/episodic memory with structured storage for procedural memory.

typescript
import { Pinecone } from "@pinecone-database/pinecone";
import { OpenAIEmbeddings } from "@langchain/openai";
import { PineconeStore } from "@langchain/pinecone";
import Redis from "ioredis";

interface MemorySystem {
  vectorStore: PineconeStore;
  stateStore: Redis;
  embeddings: OpenAIEmbeddings;
}

async function initializeMemorySystem(): Promise<MemorySystem> {
  const pinecone = new Pinecone({
    apiKey: process.env.PINECONE_API_KEY!
  });

  const pineconeIndex = pinecone.Index(process.env.PINECONE_INDEX!);
  
  const embeddings = new OpenAIEmbeddings({
    openAIApiKey: process.env.OPENAI_API_KEY
  });

  const vectorStore = await PineconeStore.fromExistingIndex(
    embeddings,
    { pineconeIndex }
  );

  const stateStore = new Redis({
    host: process.env.REDIS_HOST,
    port: parseInt(process.env.REDIS_PORT || "6379"),
    password: process.env.REDIS_PASSWORD
  });

  return { vectorStore, stateStore, embeddings };
}

async function executeAutonomousWorkflow(
  memory: MemorySystem,
  userId: string,
  workflowId: string,
  userInput: string
): Promise<string> {
  // 1. Load procedural memory (workflow state)
  const workflowState = await loadWorkflowState(memory.stateStore, workflowId);
  
  // 2. Retrieve episodic memory (past interactions)
  const pastInteractions = await recallRelevantEpisodes(
    memory.vectorStore,
    userId,
    userInput,
    3
  );

  // 3. Query semantic memory (knowledge base)
  const relevantKnowledge = await queryKnowledge(
    memory.vectorStore,
    userInput,
    workflowState?.currentStep
  );

  // 4. Build context-aware prompt
  const prompt = buildAutonomousAgentPrompt({
    workflowState,
    pastInteractions,
    relevantKnowledge,
    userInput
  });

  // 5. Get LLM decision
  const llm = new ChatOpenAI({ modelName: "gpt-4-turbo" });
  const response = await llm.invoke([new HumanMessage(prompt)]);

  // 6. Update procedural memory based on action taken
  if (workflowState) {
    await progressWorkflow(
      memory.stateStore,
      workflowId,
      workflowState.currentStep,
      determineNextStep(response.content as string),
      { lastUserInput: userInput }
    );
  }

  // 7. Store episodic memory
  await storeEpisode(memory.vectorStore, {
    userId,
    interaction: `User: ${userInput}\nAgent: ${response.content}`,
    outcome: 'neutral', // Determine based on workflow completion
    timestamp: new Date(),
    metadata: { workflowId, step: workflowState?.currentStep }
  });

  return response.content as string;
}

function buildAutonomousAgentPrompt(context: {
  workflowState: WorkflowState | null;
  pastInteractions: Episode[];
  relevantKnowledge: string[];
  userInput: string;
}): string {
  return `You are an autonomous business workflow agent.

CURRENT WORKFLOW STATE:
${context.workflowState ? `
- Current Step: ${context.workflowState.currentStep}
- Completed Steps: ${context.workflowState.completedSteps.join(', ')}
- Collected Data: ${JSON.stringify(context.workflowState.collectedData)}
` : 'No active workflow'}

RELEVANT PAST INTERACTIONS:
${context.pastInteractions.map((ep, i) => `
[Interaction ${i + 1}]
${ep.interaction}
Outcome: ${ep.outcome}
`).join('\n')}

RELEVANT KNOWLEDGE:
${context.relevantKnowledge.map((k, i) => `[${i + 1}] ${k}`).join('\n')}

USER MESSAGE: ${context.userInput}

Based on the workflow state, past interactions, and available knowledge, provide an appropriate response and determine the next action. Be autonomous and goal-directed.`;
}

function determineNextStep(llmResponse: string): string {
  // Parse LLM response to extract next step
  // In production, use structured output or function calling
  if (llmResponse.includes('collect payment')) return 'payment_collection';
  if (llmResponse.includes('verify identity')) return 'identity_verification';
  if (llmResponse.includes('complete')) return 'workflow_complete';
  return 'continue_conversation';
}

Why this works: Vector stores provide flexible semantic retrieval while Redis provides fast, structured state management. This combination enables both intelligent decision-making and reliable workflow execution.

Memory Retrieval Strategies for Autonomous Agents

Effective retrieval is critical. Bad retrieval means autonomous agents make uninformed decisions.

Time-Aware Semantic Retrieval

typescript
interface ScoredMemory {
  content: string;
  score: number;
  timestamp: Date;
  metadata: Record<string, any>;
}

function calculateMemoryRelevance(
  semanticSimilarity: number,
  timestamp: Date,
  importanceWeight: number = 1.0,
  recencyDecayDays: number = 30
): number {
  const now = Date.now();
  const ageInDays = (now - timestamp.getTime()) / (1000 * 60 * 60 * 24);
  
  // Exponential decay: newer memories weighted higher
  const recencyScore = Math.exp(-ageInDays / recencyDecayDays);
  
  // Combined score
  return semanticSimilarity * 0.6 + recencyScore * 0.3 + importanceWeight * 0.1;
}

async function retrieveWithTimeAwareness(
  vectorStore: PineconeStore,
  query: string,
  userId: string,
  limit: number = 5
): Promise<ScoredMemory[]> {
  // Get more results than needed for reranking
  const results = await vectorStore.similaritySearchWithScore(
    query,
    limit * 3,
    { userId }
  );

  // Rerank based on time-awareness
  const scoredMemories: ScoredMemory[] = results.map(([doc, similarity]) => ({
    content: doc.pageContent,
    score: calculateMemoryRelevance(
      similarity,
      new Date(doc.metadata.timestamp),
      doc.metadata.importance || 1.0
    ),
    timestamp: new Date(doc.metadata.timestamp),
    metadata: doc.metadata
  }));

  // Sort by combined score and return top results
  return scoredMemories
    .sort((a, b) => b.score - a.score)
    .slice(0, limit);
}

Production insight: Semantic similarity alone isn't enough. Recent interactions matter more than old ones, even if old ones are semantically closer.

Multi-Index Strategy for Autonomous Agents

typescript
enum MemoryNamespace {
  EPISODIC = 'episodic',
  SEMANTIC = 'semantic',
  USER_PREFERENCES = 'preferences',
  WORKFLOW_HISTORY = 'workflows'
}

async function retrieveFromMultipleIndexes(
  vectorStore: PineconeStore,
  query: string,
  userId: string,
  namespaces: MemoryNamespace[]
): Promise<Map<MemoryNamespace, Document[]>> {
  const results = new Map<MemoryNamespace, Document[]>();

  for (const namespace of namespaces) {
    const docs = await vectorStore.similaritySearch(
      query,
      3,
      { userId, namespace }
    );
    results.set(namespace, docs);
  }

  return results;
}

async function buildComprehensiveContext(
  vectorStore: PineconeStore,
  userId: string,
  query: string
): Promise<string> {
  const memories = await retrieveFromMultipleIndexes(
    vectorStore,
    query,
    userId,
    [
      MemoryNamespace.USER_PREFERENCES,
      MemoryNamespace.EPISODIC,
      MemoryNamespace.SEMANTIC
    ]
  );

  const preferences = memories.get(MemoryNamespace.USER_PREFERENCES) || [];
  const episodes = memories.get(MemoryNamespace.EPISODIC) || [];
  const knowledge = memories.get(MemoryNamespace.SEMANTIC) || [];

  return `USER PREFERENCES:
${preferences.map(d => d.pageContent).join('\n')}

RELEVANT PAST INTERACTIONS:
${episodes.map(d => d.pageContent).join('\n')}

RELEVANT KNOWLEDGE:
${knowledge.map(d => d.pageContent).join('\n')}`;
}

Autonomous agent benefit: Different namespaces allow specialized retrieval strategies. User preferences never expire, episodic memory decays over time, semantic knowledge stays fresh.

Handling Edge Cases in Production Autonomous Agents

Concurrent Workflow Updates

When multiple agents or systems update the same workflow state:

typescript
async function updateWorkflowWithOptimisticLocking(
  stateStore: Redis,
  workflowId: string,
  updateFn: (state: WorkflowState) => WorkflowState,
  maxRetries: number = 3
): Promise<WorkflowState> {
  let retries = 0;

  while (retries < maxRetries) {
    const key = `workflow:${workflowId}`;
    
    // Watch the key for changes
    await stateStore.watch(key);
    
    const currentData = await stateStore.get(key);
    if (!currentData) {
      throw new Error('Workflow not found');
    }

    const currentState = JSON.parse(currentData);
    const updatedState = updateFn(currentState);

    // Attempt atomic update
    const multi = stateStore.multi();
    multi.set(key, JSON.stringify(updatedState));
    
    const results = await multi.exec();
    
    if (results !== null) {
      // Success - no concurrent modification
      return updatedState;
    }

    // Retry on conflict
    retries++;
    await new Promise(resolve => setTimeout(resolve, 100 * retries));
  }

  throw new Error('Failed to update workflow after maximum retries');
}

Memory Pruning for Cost Management

typescript
interface MemoryPruningPolicy {
  maxAge: number; // Days
  minImportance: number;
  maxStorageSize: number; // MB
}

async function pruneOldMemories(
  vectorStore: PineconeStore,
  policy: MemoryPruningPolicy
): Promise<number> {
  const cutoffDate = new Date();
  cutoffDate.setDate(cutoffDate.getDate() - policy.maxAge);

  // Query old, low-importance memories
  const query = {
    filter: {
      timestamp: { $lt: cutoffDate.toISOString() },
      importance: { $lt: policy.minImportance }
    }
  };

  // In production, implement batch deletion
  // This is a simplified example
  let deletedCount = 0;
  
  // Implementation depends on your vector DB
  // Most support filtering and batch operations
  
  return deletedCount;
}

// Run as scheduled job
async function scheduleMemoryPruning(
  vectorStore: PineconeStore,
  intervalHours: number = 24
): Promise<void> {
  setInterval(async () => {
    const policy: MemoryPruningPolicy = {
      maxAge: 90, // 90 days
      minImportance: 0.3,
      maxStorageSize: 1000 // 1GB
    };

    const deleted = await pruneOldMemories(vectorStore, policy);
    console.log(`Pruned ${deleted} old memories`);
  }, intervalHours * 60 * 60 * 1000);
}

Preventing Memory Poisoning

typescript
function sanitizeBeforeStorage(content: string, userId: string): string | null {
  // Remove PII that shouldn't be stored
  const piiPatterns = [
    /\b\d{3}-\d{2}-\d{4}\b/, // SSN
    /\b\d{16}\b/, // Credit card
    /\b[\w.-]+@[\w.-]+\.\w+\b/ // Email (optionally keep)
  ];

  let sanitized = content;
  for (const pattern of piiPatterns) {
    sanitized = sanitized.replace(pattern, '[REDACTED]');
  }

  // Reject if too short or too long
  if (sanitized.length < 10 || sanitized.length > 10000) {
    return null;
  }

  // Reject gibberish or malformed content
  if (!/[a-zA-Z]{3,}/.test(sanitized)) {
    return null;
  }

  return sanitized;
}

async function storeWithValidation(
  vectorStore: PineconeStore,
  userId: string,
  content: string,
  metadata: Record<string, any>
): Promise<boolean> {
  const sanitized = sanitizeBeforeStorage(content, userId);
  
  if (!sanitized) {
    console.warn(`Rejected invalid memory for user ${userId}`);
    return false;
  }

  await storeEpisode(vectorStore, {
    userId,
    interaction: sanitized,
    outcome: 'neutral',
    timestamp: new Date(),
    metadata
  });

  return true;
}

Choosing Your Autonomous Agent Memory Stack

Your technology choices depend on your autonomous agent's requirements.

For Customer Service Autonomous Agents

Vector Database: Pinecone or Weaviate for semantic search across past tickets and knowledge base
State Management: Redis for real-time conversation state and workflow tracking
Long-term Storage: PostgreSQL with pgvector for audit trails and analytics
Embedding Model: OpenAI text-embedding-3-small for cost efficiency

Why this stack: Customer service needs fast semantic retrieval, stateful conversation handling, and compliance-friendly audit logs.

For Sales Workflow Automation

Vector Database: Weaviate for CRM integration and contact history
State Management: DynamoDB for serverless, scalable workflow state
Event Store: PostgreSQL for tracking sales pipeline progression
Embedding Model: OpenAI text-embedding-3-large for nuanced understanding

Why this stack: Sales workflows require integration with existing systems, serverless scalability, and high-quality semantic understanding for personalization.

For Multi-Agent Business Process Automation

Vector Database: Qdrant for on-premise deployments with sensitive data
State Management: Redis Cluster for distributed coordination
Message Queue: RabbitMQ or Apache Kafka for inter-agent communication
Orchestration: Temporal.io for complex, long-running workflows

Why this stack: Multi-agent systems need robust coordination, fault tolerance, and observability across distributed autonomous agents.

Best Practices for Production Autonomous Agents

1. Implement Memory Versioning

typescript
interface VersionedMemory {
  id: string;
  userId: string;
  content: string;
  version: number;
  previousVersion?: string;
  timestamp: Date;
}

async function updateMemoryWithVersioning(
  database: any,
  memoryId: string,
  newContent: string
): Promise<VersionedMemory> {
  const current = await database.findOne({ id: memoryId });
  
  const newVersion: VersionedMemory = {
    id: generateId(),
    userId: current.userId,
    content: newContent,
    version: current.version + 1,
    previousVersion: memoryId,
    timestamp: new Date()
  };

  await database.insert(newVersion);
  return newVersion;
}

2. Monitor Memory Quality

typescript
interface MemoryMetrics {
  retrievalLatency: number;
  relevanceScore: number;
  utilizationRate: number;
  storageSize: number;
}

async function trackMemoryMetrics(
  queryTime: number,
  relevanceScore: number
): Promise<void> {
  // Send to monitoring service
  await metrics.record('memory.retrieval_latency', queryTime);
  await metrics.record('memory.relevance_score', relevanceScore);
}

3. Implement Graceful Degradation

typescript
async function retrieveWithFallback(
  vectorStore: PineconeStore,
  query: string,
  userId: string
): Promise<Document[]> {
  try {
    return await vectorStore.similaritySearch(query, 5, { userId });
  } catch (error) {
    console.error('Vector search failed, falling back to keyword search', error);
    // Fallback to simpler retrieval method
    return await keywordSearch(query, userId);
  }
}

Performance Optimization for Autonomous Agent Memory

Caching Strategy

typescript
import { LRUCache } from 'lru-cache';

const embeddingCache = new LRUCache<string, number[]>({
  max: 10000,
  ttl: 1000 * 60 * 60 // 1 hour
});

async function getEmbeddingWithCache(
  embeddings: OpenAIEmbeddings,
  text: string
): Promise<number[]> {
  const cacheKey = Buffer.from(text).toString('base64').slice(0, 100);
  
  const cached = embeddingCache.get(cacheKey);
  if (cached) {
    return cached;
  }

  const embedding = await embeddings.embedQuery(text);
  embeddingCache.set(cacheKey, embedding);
  
  return embedding;
}

Batch Processing

typescript
async function batchStoreMemories(
  vectorStore: PineconeStore,
  memories: Array<{ userId: string; content: string; metadata: any }>
): Promise<void> {
  const documents = memories.map(m => new Document({
    pageContent: m.content,
    metadata: { userId: m.userId, ...m.metadata }
  }));

  // Batch insert - much faster than individual inserts
  await vectorStore.addDocuments(documents);
}

Real-World Implementation Example: Autonomous Customer Onboarding Agent

typescript
async function runOnboardingAgent(
  memory: MemorySystem,
  userId: string,
  sessionId: string,
  userMessage: string
): Promise<string> {
  // Check if onboarding workflow exists
  let workflow = await loadWorkflowState(memory.stateStore, sessionId);
  
  if (!workflow) {
    // Initialize new onboarding workflow
    workflow = {
      workflowId: sessionId,
      currentStep: 'greeting',
      completedSteps: [],
      pendingActions: [],
      collectedData: {},
      startedAt: new Date(),
      lastUpdated: new Date()
    };
    await saveWorkflowState(memory.stateStore, workflow);
  }

  // Retrieve user's past onboarding attempts (if any)
  const pastAttempts = await recallRelevantEpisodes(
    memory.vectorStore,
    userId,
    'onboarding',
    2
  );

  // Get onboarding knowledge base
  const onboardingGuide = await queryKnowledge(
    memory.vectorStore,
    workflow.currentStep,
    'onboarding'
  );

  // Build autonomous agent prompt
  const prompt = `You are an autonomous onboarding agent.

WORKFLOW STATE:
Current Step: ${workflow.currentStep}
Completed: ${workflow.completedSteps.join(', ')}
Collected Data: ${JSON.stringify(workflow.collectedData)}

PAST ATTEMPTS:
${pastAttempts.map(a => a.interaction).join('\n')}

ONBOARDING GUIDE:
${onboardingGuide.join('\n')}

USER MESSAGE: ${userMessage}

Based on the current step, respond appropriately and determine:
1. What information to collect
2. What the next step should be
3. Whether onboarding is complete`;

  const llm = new ChatOpenAI({ modelName: "gpt-4-turbo" });
  const response = await llm.invoke([new HumanMessage(prompt)]);

  // Parse response and update workflow
  const nextStep = determineNextStep(response.content as string);
  await progressWorkflow(
    memory.stateStore,
    sessionId,
    workflow.currentStep,
    nextStep,
    { lastResponse: userMessage }
  );

  // Store this interaction
  await storeEpisode(memory.vectorStore, {
    userId,
    interaction: `Step: ${workflow.currentStep}\nUser: ${userMessage}\nAgent: ${response.content}`,
    outcome: nextStep === 'workflow_complete' ? 'success' : 'neutral',
    timestamp: new Date(),
    metadata: { workflowType: 'onboarding', sessionId }
  });

  return response.content as string;
}

Conclusion: Building Truly Autonomous AI Agents

Autonomous AI agents are only as good as their memory systems. The five types of agentic memory—working, episodic, semantic, procedural, and meta-memory—work together to enable true autonomy.

Your autonomous agents need working memory to maintain immediate context, episodic memory to personalize interactions, semantic memory to access knowledge, procedural memory to execute multi-step workflows, and meta-memory to improve over time.

Key takeaways:

  • •Start with procedural memory for workflow automation—it provides immediate business value
  • •Add episodic memory to personalize user interactions and avoid repetition
  • •Implement semantic memory to reduce agent hallucinations with grounded knowledge
  • •Use functional TypeScript patterns for maintainable, scalable memory systems
  • •Monitor memory quality and implement graceful degradation

Your implementation roadmap:

  1. Define your autonomous workflows and state transitions
  2. Implement procedural memory with Redis or DynamoDB
  3. Add vector-based episodic and semantic memory
  4. Build time-aware retrieval strategies
  5. Monitor, measure, and optimize based on real usage

The future of business automation is autonomous agents that remember, learn, and adapt. Start building yours today.

Further Reading:

Written by

Usama Amjid

Backend Engineer & Node.js Architect

Get in Touch