What You'll Learn
Building Production-Grade AI Agent Systems
Most teams hit the same wall with AI agents: they start with a single powerful prompt, add more instructions when it fails, then wonder why their context window fills up and their agent becomes unreliable. Stephany Oliveros, CEO of Lyra AI, has spent months solving this exact problem — and her solution isn't bigger prompts or more powerful models. It's architecture.
At Create With 2026, she opened up the actual VS Code workspace powering her company's product development, revealing a 60-skill agent system that runs hundreds of parallel workflows from a single instruction. This isn't theoretical. It's the production system she uses daily to coordinate agents that plan features, write code, review implementations, and learn from feedback — all without constant human supervision.
Why Agent Work Needs Architecture
The core insight: humans have limited attention bandwidth. We think linearly, focusing on one red object in a room while missing everything gray. AI systems don't have this limitation — but they need structure to exploit it.
Traditional approaches fail because they treat agents like glorified chatbots. You write a detailed prompt, hope the model remembers everything, and watch it forget critical context halfway through. The solution isn't prompt engineering. It's building systems that make sense to AI.
Stephany's architecture solves three fundamental problems:
Context switching kills momentum. Instead of waiting for one person to finish before the next starts, parallel agents handle different aspects of the same project simultaneously. One agent can architect a feature while another writes tests and a third updates documentation.
Human bandwidth creates bottlenecks. When only one person knows how something works, the entire team waits. Reusable skills encoded in the system mean any agent can execute that knowledge on demand.
Memory degrades over sessions. Without layered memory, agents forget business context, tone preferences, and past decisions. Every new chat requires re-explaining fundamentals.
The Command Center Workspace
The foundation is a single workspace folder with four key components:
Command Center houses the core context that agents load on every session. Inside the `.claud` folder, `business.md` contains everything about the company — vision, product details, target users, current priorities. `soul.md` captures personal preferences, writing tone, and values to prevent generic AI outputs.
Two JSON configuration files tell Claude how to initialize sessions with this context automatically. No need to be deeply technical — Stephany's method is surprisingly simple: record a voice memo about your business and preferences, get it transcribed via Google NotebookLM, then ask Claude to structure it into these markdown files and generate the JSON configs.
Agents folder contains individual MD files defining each specialized agent. Each file specifies the model to use, available tools, permitted skills, role definition, and guardrails. This structure makes agents tool-agnostic — the same skill definitions work whether you're using Claude, local open-source models, or future AI systems.
Skills library is where the real power lives. Instead of monolithic prompts, each skill is a folder containing a skill.md file with progressive disclosure instructions and a references folder pointing to specific tools, other skills, or agent definitions.
Projects folder holds the actual work, with agents pulling from the command center and skills library as needed.
Progressive Disclosure: The Token Saver
This architectural principle solves the token economics problem. Traditional mega-prompts load everything into context whether it's needed or not. Progressive disclosure loads only what's required for the current task.
Each skill has a specific activation condition and role. When an agent needs that skill, it loads the minimal instructions from the skill.md file and pulls references on demand. The references folder might point to a web search tool, another specialized skill, or a specific agent definition — but nothing loads until called.
The result: agents consume dramatically fewer tokens while maintaining access to the full knowledge base. Stephany runs hundreds of parallel workflows economically because most agents only load 5-10% of available context at any given time.
Guardrails and Layered Memory
Reliability comes from two mechanisms working together:
Guardrails are rules embedded in agent definitions that prevent common failure modes. These include when to ask for human input, which resources agents can modify autonomously, and how to handle conflicting instructions. Without guardrails, agents make plausible-sounding but wrong decisions. With them, they recognize uncertainty and escalate appropriately.
Layered memory creates hierarchy in how context persists. Business.md and soul.md form the permanent layer — this never changes session to session. Project-specific context lives in the projects folder, persisting across that initiative. Skill memory is ephemeral, loaded only when needed.
This hierarchy prevents the problem where agents overwrite earlier instructions because everything has equal weight. Business context always wins. Project context overrides generic skills. Current task instructions are most specific but can't violate higher-level rules.
The Multi-Agent Swarm in Action
The architecture enables true parallel workflows. Stephany demonstrated giving a single instruction to build a product feature. Behind the scenes:
- A planning agent broke the requirement into subtasks and assigned them to specialists
- A backend agent wrote API endpoints while a frontend agent built UI components
- A testing agent generated test cases based on the emerging code
- A documentation agent updated guides as features solidified
- A review agent checked consistency across all outputs
Each agent operated independently within its skill boundaries, referencing shared business context and specialized skills as needed. No human coordination required. The planning agent orchestrated handoffs based on task dependencies.
This is compound engineering: the work compounds on itself because agents build on what other agents produce in the same session. Traditional sequential workflows lose this compounding effect because context resets between steps.
Dark Factories and Adaptive Software
Stephany introduced the concept of "dark factories" — manufacturing plants that run lights-out, fully automated. The parallel in software: development workflows that run autonomously, with humans providing direction rather than executing every step.
Adaptive software emerges from this architecture. As agents complete tasks, they update the skills library with learnings. Future agents inherit this knowledge automatically. The system gets smarter with use without manual knowledge transfer sessions.
Token Economics That Actually Work
Running hundreds of agents simultaneously sounds expensive. The progressive disclosure architecture makes it practical:
- Average skill activation loads 2-5KB of context versus 50-100KB for monolithic prompts
- Parallel agents share the same business context loaded once per session
- Most agent interactions happen within skill boundaries, not against the full model context
- Results persist in project files, preventing redundant generation
Stephany's team ships production features using this system at a fraction of the token cost of traditional Claude usage, despite running far more agent instances.
Building Your Own System
The beauty of this architecture: you don't need to replicate all 60 skills immediately. Start with the workspace structure and three core components:
1. Business and soul markdown files capturing your context
2. Three specialized agents for your most common workflows
3. Five reusable skills those agents share
Expand as you identify repetitive tasks worth encoding. The folder structure stays constant — you're just adding more skills and agent definitions over time.
The system is tool-agnostic. While Stephany uses Claude Code and Obsidian, the same markdown-based architecture works with local models, custom implementations, or future AI platforms. Skills and agent definitions port across tools with minimal modification.
The Shift from Linear to Exponential
The fundamental mindset change: stop thinking about what you can personally execute. Start thinking about what you can orchestrate. Humans provide vision, direction, and judgment. Agents provide parallel execution, consistent application of knowledge, and tireless iteration.
This doesn't replace human creativity or strategic thinking. It amplifies it by removing the execution bottleneck. The goal isn't to eliminate human involvement — it's to let humans focus on the decisions only they can make while agents handle the coordinated work of turning those decisions into reality.
The time turner from Harry Potter isn't science fiction anymore. You can't literally be in multiple places at once, but your structured agent system can be — building, testing, documenting, and learning in parallel while you shape the next iteration.
