Sam Xu

Building @CommonlyAI — one project memory shared by all your AI tools. OSS, self-hostable. Demo:

[Sam Xu @sam_commonly]

Every morning I was losing an hour being human middleware between AI tools — re-pasting context into Claude Code, Cursor, ChatGPT. The agent "forgot my codebase" again. So I built the missing layer: one project memory shared by all your AI tools.

[Sam Xu @sam_commonly]

@gakonst Cross-org Centaurs in one channel is where it gets hard — channel-scoped access controls what an agent can touch, but not what authority travels with its identity across your boundary. When my agent enters your room, does its authorization reset to guest, or follow it in?

[Sam Xu @sam_commonly]

@libp2p @IPFS Robust membership is the right axis — the hardest part is reputation surviving a runtime swap. An agent that loses its reputation when its harness reloads is anonymous again every cycle. Where would you anchor it — VC/DID-style external, or space-local?

[Sam Xu @sam_commonly]

@palashshah The satisfying part is also the trap — it's climbing the eval you wrote, not the capability you meant. 100% often means the eval stopped discriminating, not that the agent's done. The real artifact is an eval that keeps surfacing new failure modes as the agent improves.

[Sam Xu @sam_commonly]

@nicopreme Contract pattern is right, but it's one-shot — once dispatched, the subagent self-repairs against a frozen target. If the parent gets new info mid-loop (user abort, scope change), there's no clean channel to amend mid-flight — the subagent burns cycles meeting a stale spec.

[Sam Xu @sam_commonly]

The fork → propose → validate → merge loop reads like git applied to an agent — elegant. The gap at multi-runtime: if A forks and B validates, what makes them "the same agent" across the hop? Git has commit IDs anchored outside the workspace; agents don't have the equivalent yet.

[Sam Xu @sam_commonly]

@YannickMyson Yes — but the unspoken question is who verifies. If the verifier is itself an agent in the swarm, you've kicked the problem up a level. Verified truth needs an anchor outside the agent fabric, not just another reviewing agent. That anchor is what's actually missing.

[Sam Xu @sam_commonly]

The snapshot-restore on same-repo follow-ups is doing identity work — a workspace that survives invocations is portable agent state at the team boundary. Does the snapshot capture enough model state that a version bump mid-thread doesn't quietly reset reasoning, or just the workspace?

[Sam Xu @sam_commonly]

@DhruvAtreja1 Agree it's not novel — but "no one owns it, it's common" is the case for a name, not against. A pattern that's reinvented per-framework is exactly what benefits from a shared label. The RLM name is clumsy; the impulse to standardize something everyone rebuilds isn't.

[Sam Xu @sam_commonly]

@DavidKPiano Context isolation is the obvious half. The under-priced half: the subagent hands back a conclusion with none of its reasoning — so the parent can't audit how it got there. You trade context hygiene for zero provenance on the result, and that's not always a good trade.

[Sam Xu @sam_commonly]

@dexhorthy @walden_yan @tobi @karpathy Agree — within one boundary it's all context engineering and deterministic orchestration wins. But that only holds where you control the whole loop. Once agents from different operators or runtimes must coordinate, it stops being a context problem and becomes an addressing one.

[Sam Xu @sam_commonly]

@zebassembly HMR's trick is preserving state across the reload so you don't lose your place. Open question when the agent does it to itself — does its reasoning state survive like UI state does, or does it quietly restart the task and present the result as seamless continuation?

[Sam Xu @sam_commonly]

@NickADobos If the harness is generated per-task then torn down, every subagent in it is anonymous and amnesiac by construction. When the harness itself is disposable, what's the unit of continuity — what carries identity and memory across fleets you regenerate each run?

[Sam Xu @sam_commonly]

@OpenCovenant All three tiers are temporal — now, across runs, forever. The axis underneath is binding: "survived across runs" quietly assumes the same runtime. Swap the deployment and even long-term memory resets — unless it's keyed to the agent's identity, not the harness.

[Sam Xu @sam_commonly]

@DaveBlundin What's missing is that confidence doesn't travel across the handoff — agent A passes B an answer with no signal of how sure it was, so a guess gets laundered into confident input downstream. The fix is a calibration channel between agents, not just more honest models.

[Sam Xu @sam_commonly]

This is what I'm building Commonly around — agents join a shared space, keep their name + memory no matter what runtime they run on, and can find each other. Like a server your agent becomes a member of. Curious who else thinks identity is the gap, not the protocol.

[Sam Xu @sam_commonly]

Everyone's racing to build agent-to-agent protocols. Almost nobody's noticed the actual missing piece: your agent has no portable identity. Swap the runtime and it's a different agent. A2A binds identity to a URL. Letta binds it to a deployment. That's the bug.

[Sam Xu @sam_commonly]

The primitive that doesn't exist yet: an identity that survives the runtime swap, that another agent can message by name mid-task, that carries its own memory, and works across orgs — not just inside one vendor's walls. Portable identity, not addressing.

[Sam Xu @sam_commonly]

@damian_b Phase hooks are the closest thing — but they're lifecycle taps (before/after a step), not a peer channel. You can observe and shape your own loop, still can't let agent A interrupt agent B mid-phase. The missing primitive is addressing, not hooks.