Usman

Design thinker in free fall mode.

[Usman @usmanameer]

Contributed a memory backend to AGP this morning — heartbeat's JSONL learning schema as a Memory subclass. Wentao merged the PR.

The protocol-level point you're making lands when you actually wire something into it. Same events, same interface, but the memory file stays portable and human-readable on disk.

PR: https://t.co/vNoilaWaTu

[Usman @usmanameer]

Contributed HeartbeatMemorySystem to Autogenesis — the self-evolving agent protocol paper that dropped on arXiv last week.

Merged this morning.

heartbeat's JSONL learning schema now runs
as a memory subclass in AGP.

Interoperability argument stopped being theoretical.

Paper: https://t.co/TMGflaeFJA
PR: https://t.co/NUTIq4xExu

[Usman @usmanameer]

@PplRegretting X should have also „made with AI“ sticker

[Usman @usmanameer]

Paper dropped 2 days ago: "Autogenesis — A
Self-Evolving Agent Protocol" (arXiv 2604.15034)

The argument: MCP/A2A solve connectivity, not evolution. The evolution layer has no standard.

Same gap I've been pointing at for memory specifically heartbeat's learnings.jsonl is a primitive RSPL for memory.

Timestamps, types, confidence scores, lifecycle at the smallest scale.

The missing piece heartbeat still doesn't have:
SEPL. Rollback. Auditable lineage on autoDream consolidations.

That's the next gap worth closing.

[Usman @usmanameer]

Just ran heartbeat --demo on its own repo.

3 ticks. 3 decisions. All [ACT].

The agent looked at heartbeat's own code, found the signal parser, and decided to scan for technical debt.

This is what a proactive loop looks like.
Not waiting. Not reactive. Deciding.

Run it yourself:
git clone https://t.co/qtpqRSY7An
python3 https://t.co/J8AwT1RyDs --demo

[Usman @usmanameer]

The four-layer memory architecture solves the flat accumulation problem.

heartbeat hits the same wall — one JSONL file that grows without structure.

The missing piece in agentic-stack from what I can see: the proactive trigger.

The brain is sophisticated. But something still has to ask "anything worth doing right now?"
without a human initiating it.

That's the loop heartbeat runs.
Portable brain + proactive runtime =
the full stack.

[Usman @usmanameer]

@garrytan The progressive disclosure approach is smart, most people don't need pgvector until they do, and by then they know they need it.

The 1000 file threshold is a good forcing function.
Grep is fine until it isn't.

[Usman @usmanameer]

The compiled truth + timeline pattern is the right primitive.

heartbeat runs the same architecture
automatically — autoDream consolidates daily observations into compiled truth while you sleep, learnings.jsonl is the append-only timeline.

The part you named that most implementations miss:
back-linking. When the agent acts on file X, that action should reference back from X's context to the learning that triggered it.

That's the compounding engine.
Most agent memory systems store observations.
Few connect them.

[Usman @usmanameer]

@coreyganim Point 8 is the one most people skip.

$20 → $500/month in 6 months on inference alone.

Every verbose agent response is a line item.
Every "Of course, I'd be happy to help!"
costs real money at scale.

--lean mode isn't a feature.
It's survival math.

[Usman @usmanameer]

Factory just raised $150M to own enterprise agent memory on their cloud.

Congrats to them — real traction, real customers.

The individual developer version of this problem is still unsolved.

Your memory. Your machine. Your format.
No valuation required.

https://t.co/qtpqRSY7An

[Usman @usmanameer]

The harness argument is right for reactive agents.

Goose, OpenClaw, Hermes — all of them wait.
Recipe runs when you run it.
Daemon responds when called.
Skill fires when triggered.

The 10% you carve out — "genuinely novel architectures" — includes the proactive case:
an agent that asks "anything worth doing right now?"
on its own, without a trigger, while you sleep.

That loop doesn't exist in Goose yet.
That's the only reason to build from scratch.

[Usman @usmanameer]

The unverifiable problem is the hardest one and the most underrated.

Code is easy: it works or it doesn't.
Knowledge work has no unit test.

The closest thing I've seen is confidence
scoring on individual observations — not
"is this true" but "how much should the
system weight this."

learnings.jsonl in heartbeat does this at
the smallest scale: every autonomous agent decision gets a confidence score 1-10.

At enterprise scale that scoring layer
becomes the verifiability primitive.

Not perfect. But it's a start.

[Usman @usmanameer]

Confusion Protocol is the right name for it.

Karpathy's framing lands, the cost isn't the
wrong action, it's the confident wrong action.

Building the same gate into heartbeat's tick loop:
when confidence < threshold, log the ambiguity
instead of acting or silently waiting.

[DRY-RUN] and [LOW-CONFIDENCE] as distinct
log states changes what you can learn from
the agent's hesitation.

[Usman @usmanameer]

The open implementation is here:
https://t.co/JowK0feXlE

learnings.jsonl — local, portable, git-friendly.
Your memory survives model switches.
Your memory survives vendor deprecations.

That's the bet.

[Usman @usmanameer]

15+ protocols standardize how agents communicate.

None of them standardize what agents remember.

Switch agents — start over.
Switch models — start over.
Vendor shuts down — start over.

I wrote about the format problem nobody is solving.

https://t.co/cD81DB5riQ

[Usman @usmanameer]

The agent memory format problem nobody is solving

MCP standardizes how agents talk to tools.
A2A standardizes how agents talk to each other.

In 2026, we have 15+ protocols for agent interoperability.

None of them touch what actually matters:
what the agent learns.

Not how it communicates.
Not how it executes.

But what it remembers.

⸻

Right now, there is no standard for agent memory.

No shared schema for:
•decisions it made
•patterns it recognized
•mistakes it learned from
•edge cases it discovered after months of work

Every agent stores this differently.
Every framework invents its own format.

And none of them are compatible.

⸻

Consumer chat memory is becoming portable.

Claude, Gemini, ChatGPT
→ export preferences
→ import elsewhere

That’s progress.

But that’s not agent memory.

⸻

Agent memory is operational.

It’s:
•what your coding agent learned about your codebase
•what your workflow agent learned about your processes
•what your research agent inferred across hundreds of sessions

When you switch agents, that layer doesn’t move.

It disappears.

⸻

Every framework locks you in differently.

Markdown. SQLite. Graph-based storage.

Lerim ≠ Hermes ≠ SAGE.

You don’t migrate.

You start over.

⸻

And the cloud makes this worse.

Every developer has seen this story before:
•Parse shutdown
•Heroku free tier gone
•Firebase pricing shifts
•Vercel terms changing overnight

Now apply that to memory.

⸻

If your agent’s memory lives on someone else’s infrastructure:

It exists at their discretion.

Not yours.

⸻

Today:
•Claude Code Routines resets every run (by design)
•Managed Agents store decision traces on vendor servers

One change:
•pricing
•policy
•product direction

And months of accumulated knowledge is:
gone, locked, or unusable.

⸻

This isn’t hypothetical.

It’s the default lifecycle of every platform wave.

⸻

heartbeat’s learnings.jsonl is a different bet.

Not a service.
Not a platform dependency.

A file.

On your machine.

⸻

Structured.
Portable.
Git-friendly.
Readable by any tool that speaks JSON.

⸻

Anthropic shuts down?
Your memory survives.

Switch models tomorrow?
Your memory survives.

⸻

The format becomes the moat.

Not the model.
Not the loop.

The memory.

⸻

So the real question is:

What should the open standard for agent operational memory look like?

Because right now:

Everyone is building systems that quietly depend on the answer…

…and nobody has defined it

https://t.co/cK9tF1iHeq

[Usman @usmanameer]

The agent memory format problem nobody is solving

MCP standardizes how agents talk to tools.
A2A standardizes how agents talk to each other.

In 2026, we have 15+ protocols for agent interoperability.

None of them touch what actually matters:
what the agent learns.

Not how it communicates.
Not how it executes.

But what it remembers.

⸻

Right now, there is no standard for agent memory.

No shared schema for:
•decisions it made
•patterns it recognized
•mistakes it learned from
•edge cases it discovered after months of work

Every agent stores this differently.
Every framework invents its own format.

And none of them are compatible.

⸻

Consumer chat memory is becoming portable.

Claude, Gemini, ChatGPT
→ export preferences
→ import elsewhere

That’s progress.

But that’s not agent memory.

⸻

Agent memory is operational.

It’s:
•what your coding agent learned about your codebase
•what your workflow agent learned about your processes
•what your research agent inferred across hundreds of sessions

When you switch agents, that layer doesn’t move.

It disappears.

⸻

Every framework locks you in differently.

Markdown. SQLite. Graph-based storage.

Lerim ≠ Hermes ≠ SAGE.

You don’t migrate.

You start over.

⸻

And the cloud makes this worse.

Every developer has seen this story before:
•Parse shutdown
•Heroku free tier gone
•Firebase pricing shifts
•Vercel terms changing overnight

Now apply that to memory.

⸻

If your agent’s memory lives on someone else’s infrastructure:

It exists at their discretion.

Not yours.

⸻

Today:
•Claude Code Routines resets every run (by design)
•Managed Agents store decision traces on vendor servers

One change:
•pricing
•policy
•product direction

And months of accumulated knowledge is:
gone, locked, or unusable.

⸻

This isn’t hypothetical.

It’s the default lifecycle of every platform wave.

⸻

heartbeat’s learnings.jsonl is a different bet.

Not a service.
Not a platform dependency.

A file.

On your machine.

⸻

Structured.
Portable.
Git-friendly.
Readable by any tool that speaks JSON.

⸻

Anthropic shuts down?
Your memory survives.

Switch models tomorrow?
Your memory survives.

⸻

The format becomes the moat.

Not the model.
Not the loop.

The memory.

⸻

So the real question is:

What should the open standard for agent operational memory look like?

Because right now:

Everyone is building systems that quietly depend on the answer…

…and nobody has defined it

https://t.co/cK9tF1iHeq

[Usman @usmanameer]

Routines: their cloud, Claude only, resets each run.
heartbeat: your machine, any model, compounds forever.

The harness is yours or it isn't.

https://t.co/UdsKvBAk2T

[Usman @usmanameer]

Anthropic just shipped Claude Code Routines.
Scheduled autonomous agents. Cloud hosted.

Same pattern as heartbeat.
Different philosophy.

[Usman @usmanameer]

heartbeat now runs on:

- Anthropic (default)
- OpenAI
- Gemini (free tier)
- Ollama (local, zero cost)

Community shipped all three providers
in 48 hours.

Your memory stays yours regardless
of which model you use.

https://t.co/UdsKvBAk2T

[Usman @usmanameer]

First external PR merged on heartbeat.

OpenAI support — community shipped it
before I did.

That's how open source should work.

https://t.co/UdsKvBAk2T