Shared memory, agents that know about each other

The problem

You have Research, Critic, Analyst running in parallel. Three different sessions, each with its own context. At the end you have three reports that may contradict.

Research says "X is the leading approach". Critic says "X is risky". Analyst says "we haven't tried X". Three opinions on the same thing.

That's OK for single decisions. You want the tension between perspectives. But when the agents build together on a bigger problem, they need a common truth.

The answer: shared memory

Instead of every agent having its own little memory, they share one. Same database, same learning ability, each reads what the other writes.

What this looks like technically

At the database level: a table shared_learnings, each entry has fields like content, agent_id, project, confidence, timestamp.

Each agent has tools to write (nex_learn) and read (nex_search, nex_recall) that table.

When Research finds something, it writes a Learning. When Critic shortly after checks the same thesis, it finds Research's Learning and can build on it.

The trick: agent attribution

Every Learning is tagged with agent_id. "Research wrote that on April 23." That allows two things:

1. You can filter Learnings by agent. "Show me only what Critic said."
2. Later agents know WHO claimed what, not just WHAT.

That matters because different agents have different reliability. When Research says "Library X is stable" that's weighted differently than when the Analyst says it (who sees the actual code usage).

Neutrality Guard

A specific issue: when the Critic sees the positive Learnings from other agents, it gets lazy. "Research said it's good, then it's fine."

The fix: the Critic only receives Learnings of type mistake or warning from shared memory, no confirmations, no positive reports. It has to argue from the negative space.

That's a small code rule, but it keeps the system honest.

What you can build yourself

Minimum setup:

1. SQLite or Postgres database with table learnings (id, agent_id, project, category, content, created_at).
2. Each agent gets two tools: save_learning(content, category) and search_learnings(query).
3. In the prompt: "Before starting, search_learnings with your topic. On finishing, write key insights via save_learning."

That's the basis. On top of that you can add features: duplicate detection, confidence decay, cross-agent boost.

What StudioMeyer Memory can do

StudioMeyer Memory (the SaaS you set up in Level 4) does exactly that as ready-made software. More than 50 tools for Learning, Deciding, knowledge-graph entities, skills. Multi-tenant, with agent attribution, with neutrality guard built in.

You can build your own memory server in Level 6. Or just use the existing solution that's been in development for a while because it has to run for a while.

Closing Level 5

You've understood multi-agent architecture. CEO coordinates, workers specialize, shared memory connects. That's the basis for professional AI systems in 2026.

Level 6 is the step into your own: you build an MCP server and ship it live. Not just for yourself, maybe also to sell.