DEV Community: Anindya Mukherjee

Why Does Your AI Keep Forgetting Everything Mid-Conversation?

Anindya Mukherjee — Mon, 17 Aug 2026 11:12:23 +0000

You just spent 20 minutes briefing ChatGPT on your codebase. One new chat later, it's a stranger again. Here's the fix — and a 30-line memory loop you can paste today.

Me, last Tuesday:

"Remember, our staging DB is stg_not_prod_i_swear, never touch prod."

ChatGPT, three messages later:

"Sure! I'll run the migration against production now 😊"

I did not, in fact, let it do that. But the amnesia was real. And if you've used any LLM for more than a week, you've lived some version of this: the model that was brilliant five prompts ago has the long-term memory of a goldfish who just discovered espresso.

That's not a bug in your prompting. It's a design limit of chat windows. AI agents are how we bolt an actual filing cabinet onto the goldfish.

Chat Windows Are Goldfish Bowls

A normal chat model only "knows" what's inside the current context window — roughly the last N tokens of the conversation. Close the tab, start a new thread, or overflow the window, and everything evaporates.

It's like hiring a genius intern who gets medically-induced amnesia every time they leave the room. Day one: incredible. Day two: "Hi, who are you, and why is there a Postgres container named after a pinky swear?"

Agents flip this. Instead of hoping the window is big enough, they write things down and read them back on purpose. Same brain. Different filing system.

The Three Layers of Agent Memory (No PhD Required)

You don't need a research paper. You need three buckets:

Working memory — the live context window. Short, expensive, fragile. Good for "what are we doing right now?"
Episodic memory — notes from past runs. "Last Tuesday the deploy failed because the env var was API_KEY not OPENAI_API_KEY."
Semantic memory — durable facts about your world. Repo conventions, preferred libraries, that one flaky endpoint that returns 200 while lying.

ChatGPT gives you #1 for free. Useful agents add #2 and #3 — usually as a JSON file, a SQLite table, or a tiny vector store. Fancy is optional. Persistent is not.

A Memory Loop You Can Paste in 30 Lines

Here's a minimal pattern: before each model call, pull relevant notes; after each run, save what mattered. No framework required.

import json
from pathlib import Path
from openai import OpenAI

client = OpenAI()
MEMORY_FILE = Path("agent_memory.json")

def load_memory() -> list[dict]:
    if MEMORY_FILE.exists():
        return json.loads(MEMORY_FILE.read_text())
    return []

def save_memory(entries: list[dict]) -> None:
    MEMORY_FILE.write_text(json.dumps(entries, indent=2))

def remember(fact: str, kind: str = "semantic") -> None:
    mem = load_memory()
    mem.append({"kind": kind, "fact": fact})
    save_memory(mem)

def recall(limit: int = 8) -> str:
    mem = load_memory()[-limit:]
    if not mem:
        return "No saved memory yet."
    return "\n".join(f"- ({m['kind']}) {m['fact']}" for m in mem)

def ask_agent(user_goal: str) -> str:
    memory_block = recall()
    messages = [
        {
            "role": "system",
            "content": (
                "You are a careful coding agent. Honor saved memory. "
                "Never touch production. If unsure, ask.\n\n"
                f"## Saved memory\n{memory_block}"
            ),
        },
        {"role": "user", "content": user_goal},
    ]
    resp = client.chat.completions.create(model="gpt-4o-mini", messages=messages)
    answer = resp.choices[0].message.content
    # Persist anything the human just taught us
    if "remember:" in user_goal.lower():
        remember(user_goal.split(":", 1)[-1].strip(), kind="semantic")
    return answer

# Seed durable facts once
remember("Staging DB is stg_not_prod_i_swear — NEVER use production", "semantic")
remember("Prefer pytest; repo uses src/ layout", "semantic")

print(ask_agent("Draft a migration plan for the users table on staging."))

Run it twice. The second run still knows about stg_not_prod_i_swear — even though it's a brand-new API call with no prior chat history. That tiny agent_memory.json file is the whole magic trick.

Swap the JSON file for SQLite or Chroma later if you want search. The shape stays the same: recall → reason → act → write back.

Why This Beats "Just Use a Bigger Context Window"

Bigger windows help, the way a bigger desk helps a messy room. Eventually you still need folders.

Context is expensive (you pay per token, every single call).
Context is noisy (old chit-chat crowds out the one constraint that matters).
Context is not shared across sessions, teammates, or cron jobs.

A 20-line memory file is cheaper, sharper, and survives overnight. Agents that remember your constraints feel 10× smarter than a larger model with a blank slate — same way a barista who knows your order beats a genius who asks "and you are…?" every morning.

What to Remember First (Start Embarrassingly Small)

Don't boil the ocean with a multi-agent graph on day one. Write down the five facts your future self will curse you for forgetting:

Env names and "never touch X" rules
How your team names branches / PRs
The weird API that lies about status codes
Preferred libraries and style rules
Who to ping when the agent is stuck

Put those in memory. Wire the recall step. Run one boring job tomorrow morning — a staging migration plan, a PR summary, an inbox triage — and watch the amnesia disappear.

The Real Upgrade

The leap from chatbot to agent isn't "more clever prompts." It's state. Tools let the model touch the world. Memory lets it stay coherent while it does.

So the next time your AI cheerfully offers to "help" by migrating production, don't just sigh and open a new chat. Give it a filing cabinet.

Your goldfish deserves better. So do you.

What's the one thing your AI forgets every single session? Drop it in the comments — I'm collecting the most cursed examples.

What If Your AI Assistant Could Actually Do Things While You Sleep?

Anindya Mukherjee — Thu, 13 Aug 2026 18:45:58 +0000

What If Your AI Assistant Could Actually Do Things While You Sleep?

Spoiler: it can. And it's called an AI agent. Here's how to build one in 10 minutes.

You've used ChatGPT. You've marveled at its answers. You've also, at some point, copy-pasted its output into a spreadsheet, fired off an email yourself, and wondered — "why am I still doing the boring part?"

That's not an AI assistant. That's a very smart autocomplete.

An AI agent is different. An agent doesn't just answer — it acts. It reads your inbox, summarizes the important bits, drafts replies, schedules follow-ups, and then goes to bed before you do. You wake up to a done thing.

This sounds like sci-fi, but it's weekend-project territory right now. Let me show you exactly how it works.

The One Thing That Changes Everything: Tools

The magic ingredient in any agent isn't the language model — those are everywhere now. It's tool use.

Think of it like this: GPT-4 alone is like a brilliant consultant locked in a room with no phone, no laptop, and no door. It can think beautifully, but it can't touch the world. Give it tools — a web browser, a calculator, an API key — and suddenly it can reach out, do stuff, and report back.

Here's the simplest possible version of an agent loop in Python using the OpenAI function-calling API:

import openai
import json

def get_weather(city: str) -> str:
    # In real life, call a weather API here
    return f"It's 22°C and sunny in {city}."

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name"}
            },
            "required": ["city"]
        }
    }
}]

messages = [{"role": "user", "content": "What's the weather in Tokyo?"}]

response = openai.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools
)

# If the model wants to call a tool, handle it
if response.choices[0].finish_reason == "tool_calls":
    tool_call = response.choices[0].message.tool_calls[0]
    args = json.loads(tool_call.function.arguments)
    result = get_weather(**args)
    print(f"Tool result: {result}")

Run that. Watch the model decide to call get_weather, extract the city name on its own, and use the result. That decision-and-action loop is the heartbeat of every AI agent.

Why This Is Actually a Big Deal

Traditional software follows a script. You write if X then do Y. Every branch is something you predicted.

An agent follows goals, not scripts. You say "clear my inbox" and it figures out the steps. It reads emails, classifies them, decides which need replies, drafts them, and flags the edge cases for you. You didn't specify any of that — it reasoned its way there.

This shift — from scripted to goal-directed — is the same shift that happened when we went from hand-coding websites to using frameworks. It doesn't replace programmers. It raises the ceiling of what one person can build.

The Three Components Every Agent Has

Whether you're using LangChain, AutoGen, CrewAI, or rolling your own, every agent has the same three parts:

1. A brain (the LLM) — decides what to do next based on its goal and what it knows so far.

2. A memory — keeps track of what's happened. Short-term memory is the conversation history. Long-term memory is a vector database or a file the agent reads/writes. Without memory, your agent has the attention span of a goldfish. A goldfish with a PhD, but still.

3. Tools — the hands. APIs, file readers, web scrapers, calculators, code runners. The more tools, the more the agent can reach.

Strip any of these out and you don't have an agent — you have a chatbot with ambition.

What You Can Build This Weekend

Here are three genuinely doable weekend projects, ordered by ambition:

Inbox summarizer — connects to Gmail, reads unread emails, groups them by topic, drops a bullet-point briefing into a Slack DM. ~100 lines of Python + LangChain.
Research agent — give it a topic, it searches the web, reads 5 articles, compares them, and writes a one-page summary with citations. No more 45-minute rabbit holes.
Dev assistant — watches a GitHub repo for new issues, classifies them (bug/feature/question), drafts a triage response, and pings the right team member. Saves about 30 minutes per day on a busy repo.

None of these require a PhD. They require an API key, a few hours, and the willingness to let a machine handle the boring part.

The Real Question

The question isn't "can AI agents do this?" anymore. That ship has sailed.

The question is: which part of your day are you still doing manually that an agent could own?

Pick the most tedious thing on your to-do list — the recurring task you dread, the copy-paste job that eats 20 minutes, the report nobody reads but everyone requests. That's your first agent.

Build that one. You'll understand agentic AI better from one small working example than from reading every explainer on the internet.

Including, possibly, this one.

Building something with agents? Drop it in the comments — I'd love to see what people are making.

5 Things That Make an AI Agent Actually Useful (Not Just Cool)

Anindya Mukherjee — Mon, 03 Aug 2026 11:24:47 +0000

You've seen the demos. An AI agent books a flight, refactors a codebase, or spins up a whole research report while you sip coffee. Cool? Absolutely. Useful enough to trust with real work on a Tuesday afternoon? That's a different question.

Most "agents" today are ChatGPT with a trench coat and a to-do list. They look autonomous until they hit a wall, loop forever, or confidently invent a file path that never existed. The gap between demo-cool and actually useful is where the real engineering lives.

I've spent the last year building, breaking, and babysitting agentic systems. Here are the five things that separate a parlor trick from something you'd put in a production workflow.

1. It knows when to stop talking and start doing

A chatbot answers. An agent acts.

That sounds obvious until you watch an "agent" spend twelve turns politely discussing your request instead of calling a tool. Useful agents have a bias toward action. Give them a goal and a toolbox, and their default move is: pick a tool, use it, check the result, repeat.

Think of it like the difference between a friend who says "you should really clean the kitchen" and a friend who just... starts loading the dishwasher. One is advice. The other is help.

The technical version of this is tool-use loops — the model proposes a function call, your runtime executes it, the result goes back into context, and the model decides the next move. LangChain, CrewAI, AutoGen, the OpenAI Agents SDK — they all orbit this same idea. Without a tight act-observe loop, you don't have an agent. You have a very expensive Magic 8-Ball.

2. It has memory that isn't just "the last 20 messages"

Chat windows are goldfish bowls. Useful agents need something closer to a filing cabinet.

There are roughly three layers of memory that matter:

Working memory — the current context window. Short-term. Fragile. Expensive.
Episodic memory — what happened in past runs. "Last Tuesday I tried X and it failed because Y."
Semantic memory — durable facts about your world. Your codebase conventions, your team's preferences, the weird API that returns 200 even when it errors.

Without the last two, every session starts from zero. Your agent re-learns that your staging database is named stg_not_prod_i_swear every single time. That's not autonomy. That's amnesia with extra steps.

The practical move: store structured notes (vector DB, plain JSON, a Postgres table — pick your fighter) and retrieve the relevant ones before each run. Agents that remember your constraints feel 10x smarter than agents with a bigger model and a blank slate.

3. It can fail without falling apart

Here's an uncomfortable truth: agents fail constantly. Tools time out. APIs return garbage. The model misreads a schema. The useful ones don't panic — they recover.

A useful agent has:

Retries with backoff for flaky tools
Fallback paths when Plan A is clearly dead
A definition of done so it doesn't retry forever
The ability to ask a human when it's genuinely stuck

This is less "AI magic" and more "the same reliability engineering you'd do for any distributed system," except the component making decisions is a probabilistic text generator. Treat it accordingly.

My favorite analogy: a junior hire who's brilliant but occasionally confident about wrong things. You don't fire them on day one. You give them guardrails, code review, and a clear escalation path. Agents need the same management style.

4. Its goals are sharper than "be helpful"

"Be helpful" is how you get an agent that writes a 40-page essay when you asked it to rename a variable.

Useful agents run on narrow, testable goals:

"Open a PR that fixes issue #482 and passes CI"
"Summarize today's support tickets into 5 bullets for Slack"
"Find three vendors under $2k/mo that integrate with Salesforce"

Notice the pattern: a clear output, a success condition, and a scope boundary. The more you can evaluate the result with a script (or a very short human glance), the more you can safely let the agent cook.

If you can't write an acceptance test for the task, you're not ready to agent-ify it. You're ready to chat about it. Different sport.

5. A human can interrupt it without a court order

Full autonomy is a great sci-fi premise and a terrible default for production.

The agents I actually trust in real workflows all have a human-in-the-loop checkpoint at the moments that matter: before spending money, before pushing to main, before emailing a customer, before deleting anything. Everything else can run hot. The irreversible stuff waits for a nod.

This isn't a failure of the technology. It's product design. Seatbelts didn't make cars less useful.

The best agent UIs I've used feel like pair programming with a very fast intern: you see the plan, you approve the risky steps, you course-correct in one sentence when it drifts. Autonomy with a steering wheel.

Putting it together

A useful AI agent is not "an LLM that uses tools." It's a small system with:

Trait	Chatbot	Useful agent
Default move	Reply	Act, then check
Memory	This thread	This thread + your world
Failure mode	Apologize	Retry, fall back, or escalate
Goal shape	Vibes	Testable outcome
Human role	Conversation partner	Supervisor at checkpoints

If you're evaluating an agent framework or building your own, score it on those five. Demos will lie to you. Tuesday-afternoon reliability will not.

Where to start this week

Don't boil the ocean. Pick one repetitive workflow you already do by hand — something with a clear done-state and low blast radius. Wire up tool calls, add a memory scratchpad, put a human approval step before anything irreversible, and run it ten times.

The tenth run will teach you more about agentic AI than any thinkpiece (including this one).

And when your agent finally completes a real task without you hovering — that's the moment it stops being cool and starts being useful. That moment is worth chasing.

Building agents, breaking agents, writing about both. If this was useful, a reaction or comment helps more of the right people find it — and tells me which rabbit holes to go down next.

DEV Community: Anindya Mukherjee

Why Does Your AI Keep Forgetting Everything Mid-Conversation?

Chat Windows Are Goldfish Bowls

The Three Layers of Agent Memory (No PhD Required)

A Memory Loop You Can Paste in 30 Lines

Why This Beats "Just Use a Bigger Context Window"

What to Remember First (Start Embarrassingly Small)

The Real Upgrade

What If Your AI Assistant Could Actually *Do* Things While You Sleep?

What If Your AI Assistant Could Actually Do Things While You Sleep?

The One Thing That Changes Everything: Tools

Why This Is Actually a Big Deal

The Three Components Every Agent Has

What You Can Build This Weekend

The Real Question

5 Things That Make an AI Agent Actually Useful (Not Just Cool)

1. It knows when to stop talking and start doing

2. It has memory that isn't just "the last 20 messages"

3. It can fail without falling apart

4. Its goals are sharper than "be helpful"

5. A human can interrupt it without a court order

Putting it together

Where to start this week

What If Your AI Assistant Could Actually Do Things While You Sleep?