I built Sirro because I kept running into the same problem while building apps for clients. I would get a section working in one project, start another, and then explain it to a coding agent all over again. The second version was close, but it was never quite the thing I had already made.
The problem gets more obvious when you switch tools. You save your work in one agent's project files, then open a different agent and find yourself back at the beginning. The first tool may remember the conversation perfectly. That doesn't help much if the next tool can't use the finished work.
I've been thinking about how to test whether a shared library actually fixes this. It is easy to make a demo where an agent retrieves a snippet from the same tool that saved it. The harder test is to change the agent, change the project, and see whether you still get the thing you meant to keep.
A test I would trust
Start with a working piece of code in a real project. Something specific enough that rebuilding it from a prompt would lose details. Save it through one coding agent, then close that project. Open a fresh project in a different tool and ask for the same piece by name.
At that point, I want to know what actually came back. Did the new agent retrieve the saved code, or did it generate something that merely looks similar? Can I see which version it used? Will it work in the new project without quietly dropping the behavior that made the original worth saving?
I also want to try a third tool that wasn't part of the original save. If the library only works when I stay in the tool where I made the asset, then it is another local memory with a nicer interface. Portability has to survive the handoff.
This is a test plan, not a claim that every coding agent already passes it. Sirro's beta has had real authentication problems, and getting someone into the product is part of the test. A perfect retrieval flow behind a sign-in that fails for a new user isn't useful. We spent part of this week fixing that before asking anyone to judge the library itself.
Save the result, then test the transfer
A lot of agent-memory discussion starts with what an agent can remember about you. That matters, but for coding work I keep coming back to the artifact. The reason I save a section is that I want that section again, including the small decisions I don't want to explain twice.
A good memory system should make it possible to tell the difference between retrieval and imitation. If an agent says it used something from my library, I should be able to inspect the original asset and the version it pulled. Otherwise a plausible output can hide the fact that the work was rebuilt from scratch.
I don't think a standard format or a shared folder settles this on its own. Those can make an asset available. The useful question is whether I can move between the tools I actually use, name the work I already did, and keep its important details intact.
That is the test I'm interested in now: make it once, switch agents, and see if the next one can really pick it up.
Top comments (0)