Yare

Yare gives AI agents a clean handoff: what changed, what’s true, and what needs review.

Comment

Inspiration

AI coding tools are getting better, but the work still gets messy.

One agent changes files. Another claims tests passed. CI says something else. A human comes back later and has to figure out what actually happened.

Yare started from that problem: agents do not just need memory. They need a reliable work handoff that shows what changed over time.

What it does

Yare turns prior AI/tool runs into one clear current-state handoff.

It shows:

  • what changed
  • what is true
  • what is unresolved
  • what contradicts
  • what needs human review
  • what to do next

Yare also tracks how agent memory changes over time and supports semantic search over prior handoff sections using CockroachDB vector indexing.

Yare stores memory in CockroachDB, archives proof artifacts to S3, and lets agent clients inspect the same memory through CockroachDB Managed MCP.

How we built it

Yare takes run artifacts from tools like Codex, Claude, Cursor, CI jobs, and scripts.

It validates those artifacts, compiles them into a current-state packet, writes receipts, stores the memory in CockroachDB, and archives proof files to Amazon S3.

We added memory timeline and diff commands so Yare can compare the latest handoff against prior state. That shows new truths, unresolved claims, contradictions, approval items, and next-action changes.

We also added CockroachDB vector indexing so prior handoff sections can be searched by meaning.

CockroachDB Managed MCP was tested with Claude Code, Codex, and Cursor. Each client read the same Yare memory tables and reported the latest handoff.

Challenges we ran into

The hardest part was keeping the project honest.

It is easy to make “agent memory” sound bigger than it is. We focused on one real thing: a coding handoff that another agent or human can actually use.

We also had to work through real setup issues: Cockroach certificates, S3 credentials, MCP client setup, vector index setup, transaction behavior in CockroachDB, and making sure every proof result was documented without leaking secrets.

Accomplishments that we're proud of

Yare now has real proof, not just a concept.

  • CockroachDB memory smoke passed
  • CockroachDB vector search smoke passed
  • memory timeline and diff smoke passed
  • real handoff demo passed
  • S3 archive smoke passed
  • Claude Code MCP proof passed
  • Codex MCP proof passed
  • Cursor MCP proof passed
  • public site is live
  • use cases are documented
  • project is MIT open source

What we learned

Agent memory is not just chat history.

For coding work, useful memory means knowing what changed, what was verified, what is still risky, what changed since the last run, and what the next agent should do.

We also learned that MCP is strongest when multiple agent clients can read the same source of truth, and vector search is strongest when it helps agents find prior work by meaning instead of digging through logs.

What's next for Yare

Next is testing Yare on a real outside repo, not just the demo handoff.

The first target is AI coding teams: agent work before PR review, after long coding sessions, and during tool handoffs.

After that: engineering audit, compliance teams, vibe coders, docs teams, and content/research operators.

Later, Yare can add verified skill evolution: recurring patterns from prior runs can suggest better agent instructions, but still require human approval and receipts.

Built With

Share this project:

Updates