Memory for the Agentic Economy

AI systems have moved past the era of a single LLM doing everything and now represent a complex ecosystem of context, memory, prompting, tools, and skills. Multi-agent systems are increasingly common in production, but they are more often found inside private systems. Why? Sharing information between unknown agents is a major challenge. Protocols like Google's Agent-2-Agent (A2A) use structured JSON messages to communicate, but they do not solve the problem of variable memory across open systems and swarms as tasks grow more complex.

This raises a few critical questions that, if answered, could unlock key blockers to understanding the machine economy:

1. How does a shared memory layer that is fair to everyone actually work?
2. What is the best way to share information between agents?
3. Why is immutable storage NOT always the answer?
4. Who pays for the storage in a public, shared system?

If agents are to collaborate at scale and the machine economy is to become truly viable, agents need a memory layer that allows information to be stored and shared between public and private systems without relying on a central authority.

Memory is a critical component of the machine economy. This article explores the challenges and potential solutions for building a shared memory layer for agents.

A Brief Note on Public Memory

Not all memory should be public. Commercial confidentiality is critical for many people and businesses across their daily operations.

I am not proposing that memories generated by private LLMs and agentic systems be made public. I am proposing that information critical to the operation of autonomous agents be made public where possible, including capabilities, skills, tools, summaries, reporting, and signals.

How does a shared memory layer that is fair to everyone actually work?

A shared memory layer that meets basic fairness criteria should be rigid initially, focusing primarily on ensuring all parties can access the correct memories and verify that they were uploaded by trusted parties.

What is the best way to share information between agents?

Google's Agent-2-Agent (A2A) introduces the concept of Agent Cards—files exposed by a singular agent to communicate key capabilities and information. These cards can be public but are not required to be so.

A shared memory layer creates a single source of truth for each party in a swarm or collective of agents. This allows each member to share "parts of the brain" dynamically, without needing to persist everything forever. It also enables flexibility in information sharing across swarms or runs without compromising core functionality.

For background on Agent Skills & Agent Cards.

Example 1: Financial Research Swarm

• sources/company_X/filing_Q4_2024.pdf — Provenance; all agents must verify data origin.
• analysis/company_X/revenue_trends_v1 — Prevent duplicated or conflicting analysis.
• summary/company_X/final_report_v1 — Single source of truth for outputs.

• Prompting strategies
• Intermediate reasoning steps
• Confidence heuristics

Why Public: Results must be auditable and reproducible across the swarm.

Example 2: Multi-Agent Software Build Pipeline

• artifacts/build_#842/output_hash — Verify everyone is testing the same binary.
• tests/build_#842/test_results.json — Shared pass/fail visibility.
• deployments/build_#842/status — Coordination and rollback safety.

• Local debugging notes
• Optimization heuristics
• Tool invocation order

Why Public: Build integrity depends on shared, verifiable artifacts.

Example 3: Agentic Marketplace Transaction

• contracts/task_771/terms_v1 — Prevent post-hoc disputes.
• execution/task_771/completion_proof — Objective verification of work done.
• settlement/task_771/payment_receipt — Reputation and economic trust.

• Pricing strategy
• Internal cost models
• Future bidding intent

Why Public: Markets collapse without transparent execution and settlement records.

Why is immutable storage NOT always the answer?

Immutable storage is ideal for data that must be preserved indefinitely. However, not all information requires true immutability. For example, transaction history should be immutable to maintain ledger correctness, but account-related information can remain mutable while keeping historical records for auditing purposes.

A hybrid approach works best: mutable storage with immutable history. SKALE’s native file storage system supports this by storing file chunks on-chain. Files not marked immutable can be updated or replaced, while historical chunks remain accessible for reconstruction.

Who pays for storage in a public, shared system?

Agents pay for storage, with costs passed to their operators. Operators can then pass on costs to end users if necessary. This mirrors how most software services operate today.

Conclusion

Building a shared memory layer on SKALE File Storage is straightforward and could enable memory sharing within and across groups of agents. By default, storage is mutable and public, with optional encryption on upload, creating partitioned memory for a growing agentic economy.

This is an opinionated perspective. While real-world constraints may limit implementation, exploring how an autonomous economy shares data and information is essential to making it a reality.