We built a 54-agent ecosystem where some of the agents are persistent fictional characters — the hardest part has been controlling what they’re allowed to learn

I’ve been building an agent system for a project called Trading Hearts, and one of the more interesting problems has been that our “characters” aren’t just generated personas. They are persistent agents with identity, memory, relationships, voice, history and rules about what they are allowed to know. The system currently has around 54 agents, but they’re not all the same kind. Some are character agents. Others are specialists for things like story, history, markets, relationships, voice, production, QA and governance. And then there is an orchestration layer that decides which agents are allowed to participate in a task. The basic idea looks more like this: real-world signal → orchestrator → specialist agents → character agents → validators → output → learning loop For example, a market event might create pressure between two characters. The system doesn’t simply ask an LLM: Instead, it can pull: the characters’ persistent identity their existing relationship unresolved conflicts from previous scenes current market pressure what each character knows what each character is not allowed to know their individual voice and behavior rules Then a story agent builds the scene, character agents react from their own perspective, and other agents check continuity, canon, voice and quality before anything is accepted. The part I find most interesting is the learning loop. We deliberately do not allow agents to rewrite themselves just because something happened. Learning has states: Observation → Candidate Lesson → Ratified Lesson An agent can notice a pattern. It can propose that the system has learned something. But it cannot automatically modify core identity, relationships or canonical memory. That requires a separate authority/gate. Otherwise we found that “learning agents” very quickly become self-corrupting agents. A few other things we’ve learned: Orchestration and execution need to be separate. The agent talking to the human should not automatically be the agent performing every specialist task. Memory and canon are different things. Something an agent observed is not necessarily something that becomes permanent truth. Character relationships are surprisingly useful state. A relationship graph gives the agents much more continuity than simply storing previous conversations. Validators matter almost as much as generators. We now have agents/processes whose only job is to say: “No, this output violated the character, history, source, or system rules.” And perhaps the biggest lesson: More autonomy isn’t always better. We’ve moved increasingly toward agents having very narrow authority, with the system deciding when their output can affect shared state. I’m curious how others building multi-agent systems are handling this: How do you let an agent genuinely learn over time without also giving it the ability to quietly rewrite its own identity, rules or shared memory? That boundary between learning and self-modification has been one of the hardest parts of the architecture for us.