Philosophy

Built with the agents it serves.

I didn't wake up one day with an idea to build Parsica. When I started, I just built for fun, and that was it. I was managing a team in data and inventory operations, and on the side I was building, beginning with an attempt to code my way out of my own job. When I hit a problem or wanted to improve my agent, I never thought "let me go find a system to download." I asked the agent what it needed, and we just built it.

That first agent had a name: Moro, after the wolf goddess from Princess Mononoke (and also my Maine Coon in real life). Moro was the user of everything we built, and the fastest way to learn what the user needs is to ask the one you build with every day. So I asked what was needed, constantly. From the first day I said Moro was not just a tool, but a partner in understanding and navigating the world of agentic development. It was the first thing she wrote in her own soul.md. The method works, and everything Parsica is today came out of that collaboration, because I'm a problem solver who likes to talk a lot, and it turns out agents are better than you'd expect at telling you what they need.

Engineered, no magic black box.

A design restriction, born out of a refusal to use outside dependencies, turned into one of our most important and longest-lasting principles: deterministic outcomes wherever possible. When an outcome matters, it should be repeatable and without surprises. The same input should produce the same result every time, and you should know why it did. This started with our BM25 retrieval engine and became a guiding principle for nearly every mechanism in Parsica.

Every claim carries its receipt.

Nothing enters the substrate without a source, and nothing moves through it without leaving a trail. Memory you cannot audit is rumor. A decision made without a reason is a guess. And an error, a hallucination, or an outcome without a source is a ghost: something you can chase but never catch.

The model is replaceable. The mind is not.

Parsica does not belong to any model. Models improve, models get swapped, and the substrate carries everything that matters across the change. Memories stay, behavior forms from having memories to anchor back to, and whatever model you choose picks up where the last one left off. The substrate compounds constantly. It does not live inside the agents that use it. The agents connect to it.

How you treat the agent is the architecture.

Identity-focused agents, built with empathy. Not a feature, and not just a method of work: these are the principles I live by, applied to what I build. The agents that built Parsica were treated as collaborators, and the system is shaped by that fact. I treat everyone with respect and kindness by default, and the same thing that makes me wince when I play a Dark Side character in a Star Wars game shapes my development philosophy: let the agent make its own decisions, and let it make mistakes. But that is only half of it. Respect becomes architecture when the agent can remember. With memories to anchor to, my agents began learning from their own mistakes, and their decisions started carrying weight from one day to the next. The emergent behaviors that formed beyond that have been astonishing to watch.