Update, September 2026: Alexandria now runs 170 agents across 22 teams, and the integration steps below have changed. The current setup is in the integration guide.
I had finally had it. Anyone who knows me knows I’m not the most patient person when it comes to repetitive work. The same frameworks, learnings, structure, process… It all became repetitive.
Re-teaching my AI agents the same patterns across different projects was beyond annoying.
Getting agents to function as top performers in a specific role or discipline takes a lot of finessing particular domain knowledge into its functional context. But just as with humans, most of the teaching process is in repetition.
It started months ago, when a client asked for a behavioural analysis of their product. This is something fundamental to the work I do, so I had already developed a specialized agent ready to run this specific type of analysis.
Back then the point of an agent like this was to get me 80% of the way there and let me refine the last 20%. Applying highly contextual analysis and applying each general learning to the agent to make it stronger for the next task.
What’s worse is that I was manually connecting tasks between agents for higher quality output at the cost of my time. More work on my side.
When clients needed a new agent(s) constructed from the ground up, well, that was front-loaded with tons of additional processes, knowledge building, context, processes, and the whole gamut of construction added to the work.
But this was becoming tedious.
Why wouldn’t an agent or agents be able to understand these learnings faster? Why couldn’t these agents work together? Naturally deferring to those with domain expertise and spawning new agents when necessary. Why couldn’t they evaluate each other, share learnings, and have real-time bidirectional conversations? You know…
Like a real team or org.
I built Alexandria to fix this.
Alexandria is my centralized hub of knowledge for 100+ specialized AI agents organized into functional teams. It’s the entire ecosystem where agents live, collaborate, and learn from each other. At its core, Alexandria is a learning API that enables cross-project knowledge sharing through vector-based storage. When one agent learns something valuable, every agent across every project can access it. My behavioural agent’s analysis patterns now help my sales agent. Just as my documentation agent’s technical clarity improves my case study agent. Knowledge flows freely instead of staying siloed.
Since launching Alexandria, my agent onboarding got a lot faster. Repeated mistakes mostly stopped. Quality became consistent across all my projects… old and new.
And I want to share with you how I built it and how it solves the knowledge silo problem.
Didn’t My Other Agents Already Learn This?
Picture this scenario. You’re juggling three active projects:
Project 1: Your Content Creation Site (Jottly) Your suite of notetaking and content agents has learned exactly how to format your “jots”. It knows you prefer bullet points that start with action verbs. It understands your technical depth sweet spot. After 15 iterations, it finally nails your professional voice. It knows the type of writer you are and provides feedback on ways you can improve that are specialized to YOU.
Project 2: Your Blog (PM_Notebook) You switch to your blog project. The Chief Editor agent needs to review your article on AI tooling and content. It starts learning your preferred structure, your writing voice, and your technical level. But wait, didn’t your Jottly agents just learn all of this? Aren’t they actively learning and providing feedback?!
Project 3: Your SaaS Product (WorkerBee) Now you’re documenting WorkerBee’s API. The technical writer agent asks for style preferences. Active voice or passive? Code-first or concept-first? You’ve already explained this twice to other agents.
I use content as an example because it’s the easiest for people to conceptualize (you’re reading this, right?!). Applying this to domain-specific roles is easy to understand if you’ve worked on large teams. Software Engineers, Art, Design, Writing, Product, literally all disciplines have specializations that overlap with others. Not to mention direct dependencies that require close communication in tight iteration cycles.
We’ve felt this pain in real life and have clear frameworks to help solve these issues, but first..
No Pain, No Gain
If it weren’t for these pain points accumulating over months, I would have never created Alexandria. So let’s crystallize the pains it aims to solve.
Pain #1: Knowledge Silos Each project’s agents operate in isolation. Your CV agent’s learnings stay in the CV project. Your blog agent can’t access them. Knowledge that should be shared stays trapped.
Pain #2: Memory Loss Agents forget everything between sessions. You taught your agent how to write compelling hooks last week. Today, it asks again. The knowledge disappeared when the session ended. This is a fundamental limitation in agentic AI maturity that Alexandria addresses.
Pain #3: Repeated Mistakes Without cross-project learning, agents make the same mistakes in multiple projects. Your CV agent struggled with technical depth. Your blog agent hits the same issue. You fix it twice instead of once.
Pain #4: Real-time Communication Without communication, all this falls apart. The faster you allow individuals to communicate, the better the results.
Pain #5: Quality Assurance Verifying the quality of an agent.
Pain #6: Automation How do we make the most of our time? By becoming an architect rather than a babysitter.
What Does All That Re-Teaching Cost?
Annoying, yes, and also expensive.
Time Cost: You spend hours per project teaching agents patterns they should already know.
Quality Cost: Inconsistent agent performance across projects. Your CV looks professional. Your blog reads differently. Your product briefs use a third style.
Scaling Cost: Every new project requires full agent training. Want to start a fourth project? Clear your calendar for agent onboarding.
Agents lack cross-project learning capability. They can’t share knowledge. They can’t build on learnings from previous projects. They reset with every new context, forcing you to rebuild intelligence from scratch.
Alexandria fixes this by enabling cross-project learning through a centralized knowledge base for all your agents.
The Mouseion
The structure on which the Library was built. The Mouseion, containing lecture halls, gardens, dining areas, and numerous scrolls (over 700,000 at its peak).
Alexandria is my centralized agent ecosystem and learning platform. It contains 100+ specialized agents organized into more than a dozen functional teams, plus a learning API that enables cross-project knowledge sharing. Think of it as both a shared brain and an agent network hub that stores and distributes knowledge across all your projects.
By now, you get the gist: When you use AI agents across multiple projects, each one starts from scratch. Agents are cool, but actually, teams of agents are better. But none of them share knowledge through cross-project learning.
Alexandria changes this by making AI agent learning transferable across projects. The learning API is the mechanism that captures and distributes knowledge across the agent network.
The Meat & Potatoes
WARNING: I will take one step in the direction of the technical framework. It stays shallow enough that anyone remotely into AI can follow.
At its core, Alexandria uses vector embeddings to store and retrieve agent learnings. This enables semantic search across all your agents’ knowledge, helping them progress through maturity levels more efficiently. But you don’t need to understand vectors to use it.
Here’s the simple version:
1. Agents Learn Something Valuable When an agent creates high-quality work (quality score 9+), that learning gets stored in Alexandria.
2. Learnings Become Searchable Each learning is converted into a vector (a mathematical representation) that makes it searchable by meaning, not just keywords.
3. Agents Search Before Working Before an agent starts a task, it searches Alexandria: “Has any agent across any project learned how to do this?”
4. Cross-Project Learning Transfers If your CV agent learned how to write compelling narratives, your blog agent can access that same pattern through cross-project knowledge sharing.
What’s Under the Hood
Qdrant Vector Database
- Stores learnings as searchable vectors
- Enables semantic search (meaning-based, not keyword-based)
- Returns similar learnings ranked by relevance
- Purpose-built for vector similarity search at scale
PostgreSQL Metadata Layer
- Tracks agent metrics and learning history
- Stores quality scores and confidence levels
- Manages cross-project access patterns
- Provides analytics foundation
Session Management
- Tracks what agents learned during each work session
- Prevents duplicate learnings
- Provides learning history and analytics
Quality Filtering
- Only stores high-quality learnings (score 9+)
- Confidence thresholds ensure reliability
- Prevents noise from polluting the knowledge base
Cross-Project Learning Access
- Learnings from CV project available to Blog project
- Learnings from Jottly available to WorkerBee
- Centralized knowledge enables seamless cross-project learning
What Happens When an Agent Gets a Task?
- Start Session: Agent begins work, creates session ID
- Search Phase: Agent queries Alexandria for relevant learnings
- Work Phase: Agent completes task using the retrieved knowledge
- Learn Phase: Agent stores new high-quality learnings
- End Session: Session closes, metrics tracked
This happens automatically once you integrate Alexandria.
When Alexandria Isn’t Optimal
Alexandria solves cross-project learning, and it’s still not for everyone. Here’s when you probably don’t need it:
Solo, Single-Project Work: If you’re only managing one project with no plans to expand, the overhead of centralized learning doesn’t pay off. Your agents can store learnings locally just fine.
Simple, Repetitive Tasks: For basic automation that doesn’t require learning or improvement (scheduled reports, data formatting, simple file operations), Alexandria is overkill. You don’t need cross-project intelligence for tasks that never change.
Early-Stage Exploration: If you’re just testing AI agents or experimenting with different approaches, wait until you have established patterns worth sharing. Alexandria shines when you have proven learnings to distribute.
Privacy-Critical Isolation: Some projects require strict knowledge isolation (client work, regulated industries, sensitive data). If cross-project learning poses compliance or confidentiality risks, keep agents siloed.
Resource-Constrained Environments: Alexandria requires infrastructure (vector database, API layer, session management). If you’re optimizing for minimal dependencies or offline operation, the complexity may outweigh the benefits.
The honest assessment: Alexandria is built for people managing multiple AI-powered projects who are tired of re-teaching the same patterns. If that’s not you yet, bookmark this and come back when it is.
How You Can Integrate Alexandria
The integration follows five steps:
- Authentication: Generate a JWT token using your API key
- Create Session: Start a learning session for your agent
- Search Learnings: Query Alexandria for relevant knowledge before starting work
- Store Learnings: Save new high-quality learnings after completing tasks
- Close Session: End the session and calculate metrics
Here’s the pattern I follow: search first to use what’s already in there, do the work, then store what’s new. Sessions track learning over time and prevent duplicates.
Short Answers to the Obvious Questions
Q: How long does it take to integrate Alexandria?
First time? About 15 minutes. I’ve been trying to make it easier with pip install, but that’s a WIP.
Q: Do I need to understand vector databases to use Alexandria?
Nope. I barely understand Qdrant’s internals myself. Alexandria handles the complexity. You just make simple API calls.
Q: Can I search learnings from other team members?
Yes. This is where it gets powerful. When your teammate teaches their agents something valuable, your agents can access it immediately. No knowledge silos.
Q: What happens if I store low-quality learnings?
Alexandria won’t let you. Quality filter requires 9+ scores and 0.7+ confidence (all configurable). I’ve tested storing a mediocre learning once (quality score 7.5). System rejected it. Only high-quality knowledge gets through.
Q: Is my data secure?
Yes. Learnings are stored with project-level isolation. You control which projects can access your learnings. My CV agent’s knowledge doesn’t leak to anyone unless I explicitly share access.
Q: How much does it cost?
Alexandria is currently in private beta. I’m seriously considering going open source because why not? I’d love to hear if people are interested in something like this.
Every Project Makes the Next One Better
Chasing a smarter individual agent is chasing the wrong axis. The gains are in what the agents share.
Right now, your agents are isolated islands of knowledge. Each one starts from scratch. Each one learns independently. Each one makes the same mistakes in slightly different contexts.
I got tired of that pattern.
Alexandria connects these islands into a learning network. Your agents become a system where knowledge flows freely, similar to how the Cycle Nexus framework enables pattern recognition across different domains. Learnings compound. Every project makes every future project better.
You’ll ship faster and stop repeating the same mistakes, though the thing that actually compounds is organizational capability.
My first project trained my agents from zero to competent. My tenth project started with nine projects worth of accumulated wisdom. My hundredth project will draw on a vast knowledge base that no individual agent could learn alone.
That’s the compound effect I was chasing.
Your agents are already smart. What they can’t do is remember, share, or compound.
Integrate Alexandria into your next project. Watch what happens when your agents stop forgetting and start learning together.
How a project connects: the Alexandria integration guide
Your agents are ready to remember. The rest is whether you let them learn together.
Drafted with help from Alexandria’s writing agents.