Build AI Agents with Personal and Shared Memory in 15 Minutes

Building AI chat agents with persistent memory often requires weeks of integration work. Hot Chat changes that by delivering a ready-to-run demo that splits memory into two critical scopes—personal and shared—within a single project.

This open-source Next.js + TypeScript application pairs two AI agents side by side: one that remembers your preferences across every session you open, and another that tracks team decisions within a single chat channel. The entire setup takes about 15 minutes to clone, configure, and run locally, making it one of the fastest ways to experiment with memory-grounded AI workflows.

A Dual-Agent Chat Demo You Can Deploy Today

Hot Chat is a minimalist yet functional prototype built on Hot’s AI agent framework. It demonstrates how the same UI can toggle between two distinct agent behaviors without restarting the application. One agent operates in Personal Mode, where your inputs persist under your identity, and the other runs in Team Mode, where shared context lives within a channel.

The backend relies on hot-ai-agent, an open-source package under Apache 2.0 that handles transport layers, slash-command parsing, streaming responses, and MCP tool integration. The frontend connects to Hot via the @hot-dev/sdk package, offering a clean abstraction over the agent’s communication layer. Since all components are open source, developers can audit, modify, or extend the system without hidden dependencies.

Setting Up the Demo in Minutes

To run Hot Chat locally, start by installing the Hot CLI tool if it’s not already on your system. Clone the project repository, navigate into the hot-chat directory, and launch the agents with a single command. In a separate terminal, initialize the frontend environment by copying the example configuration and populating it with your API keys.

git clone 
cd hot-demos/hot-chat
hot dev --open

Next, configure the environment variables in .env by generating a new service key in the Hot Dev App and adding your Anthropic API key. The demo falls back to a placeholder response if the API key is missing, but with a valid key, you get true streaming, memory-grounded replies.

cp .env.example .env
npm install && npm run dev

Once the frontend server starts, open ` in your browser. The toolbar lets you switch between Personal and Team modes instantly, without reloading the page. This live toggle highlights how the same UI can serve vastly different agent behaviors based on memory scope.

How Memory Scope Shapes Agent Behavior

Hot Chat’s two agents differ only in how they manage context. Personal Mode treats memory as a durable extension of your identity. Type /remember I prefer launch updates that start with blockers, close the tab, and return tomorrow on any device. Ask /recall, and the same note reappears. This model suits personal assistants, journaling tools, or copilots that need to retain user-specific preferences over time.

Team Mode, by contrast, binds memory to the channel. Two engineers discussing blockers in the same thread share a single context. Type we decided to ship docs before launch, then CI is the only blocker, and later ask /ask what is blocking launch?. The agent cites the relevant records with attribution, making it ideal for team chatbots, support queues, or collaborative workspaces.

Inside the Generic, Production-Ready UI

Hot Chat’s frontend avoids framework-specific styling, presenting a neutral chat interface that feels like a real product rather than a demo. This design choice emphasizes usability: developers can drop the same UI into their own projects without reinventing interaction patterns.

Key features include:

• Quick-prompt chips that let users explore agent capabilities without memorizing slash commands. Options like Recall preferences, Daily brief, and Decisions surface common workflows in one click.

• Streaming replies that render as the agent generates text, including slash-command outputs. This consistency ensures users never see abrupt UI shifts between LLM responses and tool-triggered messages.

• File attachments that store metadata such as filenames and types. While the demo doesn’t parse content, the structure supports future extensions like document retrieval or image analysis.

• Identity controls that display the raw session_id and user_id values a Slack or Telegram adapter would generate. This transparency helps debug identity binding issues during integration.

• Agent Graph visualization in the Hot Dev App, where each slash command maps to a dedicated event handler. This modular approach eliminates monolithic dispatch logic and makes it easier to maintain or extend agent behavior.

The Framework Behind the Demo: hot-ai-agent

Most AI chat agents end up reimplementing core infrastructure: slash-command parsers, memory pipelines, streaming handlers, and session bindings. hot-ai-agent consolidates these layers into a reusable package that works across transports and providers.

The framework provides:

• A unified message format (IncomingMessage) that adapters for web, Slack, or Telegram can normalize into. Agents process messages without branching on transport type.

• Automatic slash-command parsing that strips bot suffixes like @MyBot and extracts structured {name, arg} pairs for tool invocation.

• Memory-grounded chat turns that follow a strict lifecycle: recall user context, persist new inputs, bind the request, stream the response, and persist assistant outputs. This order prevents self-contamination during retrieval.

• Stable streaming events labeled :reply:start, :delta, and :end at the agent scope, ensuring consistent event handling for UI updates.

• Per-request session binding that propagates identity and session data to LLM tools invoked mid-turn, maintaining context integrity.

• Agent-scoped stores for state, stats, error tracking, and notifications. Scheduled jobs can target specific sessions with isolated error handling.

• MCP tool exposure via annotations, allowing tools like Claude Desktop or Cursor to call agent functions directly.

Why This Approach Matters for AI Development

Hot Chat isn’t just a demo—it’s a blueprint for building memory-aware AI systems without reinventing infrastructure. By separating Personal and Team modes, developers can prototype both user-centric and collaborative agents in parallel. The open-source nature of the stack ensures transparency and extensibility, while the generic UI proves that agent behavior can evolve independently of presentation.

As AI agents move from novelty to necessity in workflows, tools like Hot’s framework will reduce the gap between concept and production. The next wave of AI-powered applications won’t just answer questions—they’ll remember context, adapt to teams, and integrate seamlessly into existing tools. Hot Chat offers a glimpse of that future today, packaged as a runnable demo ready for your next experiment.