Multi-Domain AI Context Architecture

Updated January 2026 | 8 min read

You've got your job. Your side business. Your personal life. Maybe a few clients. Each one has different people, different rules, different context.

One CLAUDE.md file won't cut it.

You need an architecture that keeps work context separate from personal context, client A separate from client B, without making you manually load the right file every time you ask a question.

This is multi-domain AI context architecture. Here's how it works.

The Problem: Context Collision

Let's say you're a real estate database manager by day and run an SEO consulting business at night. You ask your AI: "What's the status on the Smith account?"

Which Smith? The real estate lead or the SEO client?

If all your context lives in one file, the AI has to guess. Or worse, it mixes them. Gives you real estate advice when you're talking about SEO. References the wrong people. Gets your dates confused.

You can't scale AI memory with a single file. You need separation.

The Architecture: Three Layers

Multi-domain context architecture has three parts:

1. Root CLAUDE.md — The routing table that tells AI which domain you're talking about
2. Domain folders — Separate directories for each area of your life
3. Context files — Domain-specific _context.md files that hold the rules and state

The root file doesn't hold all your context. It holds the map to your context.

Layer 1: Root CLAUDE.md (The Router)

Your root CLAUDE.md sits at the top of your vault. It contains a routing table that maps keywords to domains.

Example:

| Domain | Context File | Load when prompt mentions... |
|--------|--------------|------------------------------|
| **Work** | `work/_context.md` | lead, database, CRM, agent, cleanup |
| **Business** | `business/_context.md` | client, SEO, content, article, outreach |
| **Personal** | `personal/_context.md` | budget, health, household, family |

When you mention "lead," the AI knows to load work/_context.md. When you mention "client," it loads business/_context.md. When you mention "budget," it loads personal/_context.md.

This is keyword-based routing. The AI scans your prompt for trigger words, identifies the domain, and pulls in the right context before responding.

Layer 2: Domain Folders

Each domain gets its own folder:

/SubtleBodhi/
  CLAUDE.md (root)
  /work/
    _context.md
    _log.md
    /leads/
    /reports/
  /business/
    _context.md
    _log.md
    /clients/
    /content/
  /personal/
    _context.md
    _log.md
    /finance/
    /health/

Each folder holds everything related to that domain. Client files in the business folder. Lead data in the work folder. Budget spreadsheets in the personal folder.

The structure keeps context separate. The AI doesn't confuse your work leads with your business clients because they live in different places.

Layer 3: Context Files (_context.md)

Each domain folder contains a _context.md file. This is where the domain-specific rules and state live.

For work/_context.md:

# Work Context

## Current State
- Database cleanup: 11 tags fixed, 200+ contacts remaining
- Phone duty: Transferred from Bria to me (Jan 15)
- CRM: Follow Up Boss (read-only API due to Jan 14 incident)

## Key People
- Erin (boss)
- Bria (former phone duty)
- Jim Allen (company owner)

## Rules
- Always include ID + full address when referencing a lead
- No bulk edits without explicit confirmation
- Database changes logged to work/_log.md

For business/_context.md:

# Business Context

## Active Clients
- Cryo Body Works (wellness/recovery)
- Limitless Chiro (chiropractic)
- Valley Welding (industrial B2B)

## Services
- Content briefs: $200 each
- Full articles: $500 each
- Topical authority maps: $997 each

## Rules
- Client deliverables go in business/clients/{client-name}/
- All content uses SSO + PASAIDA framework
- Invoice via Stripe, 50% upfront

The _context.md file is what the AI reads when it detects a domain keyword. It's a snapshot of everything the AI needs to know to operate in that space.

How Context Loading Works

Here's the flow when you ask a question:

1. You type: "What's the status on the Smith lead?"
2. Claude Code scans your prompt for keywords
3. Detects "lead" → maps to work domain
4. Reads CLAUDE.md routing table
5. Loads work/_context.md
6. Responds with work context active

You don't have to tell the AI which context to use. The keyword "lead" triggers it.

If you'd said "What's the status on the Smith client?" the word "client" would've triggered business/_context.md instead.

Same question, different context, different response.

Multiple Keyword Triggers

Sometimes your prompt mentions multiple domains. "I need to update the client deliverable schedule and check the lead database."

The AI detects both "client" (business) and "lead" (work). It loads both context files. Now it can reference both domains in the same response.

This is multi-domain context stacking. The AI doesn't pick one or the other. It brings in everything relevant.

Domain Isolation vs. Cross-Domain Reference

Most of the time, domains stay separate. Work context doesn't need to know about business context. Personal context doesn't need to know about work context.

But sometimes they overlap. Maybe you're tracking business revenue in your personal finance spreadsheet. Or you're using your work CRM skills to set up a client management system for your business.

That's fine. The architecture doesn't prevent cross-domain reference. It just prevents accidental mixing.

If you want the AI to reference both domains, use keywords from both. If you want it to stay in one lane, use keywords from one.

Scaling Beyond Three Domains

Three domains is the starting point. You can have more.

Maybe you have five freelance clients, each with their own folder. Each gets its own _context.md file. Each gets its own set of trigger keywords.

| Domain | Context File | Load when prompt mentions... |
|--------|--------------|------------------------------|
| **Client A** | `clients/acme/_context.md` | Acme, industrial, welding |
| **Client B** | `clients/zenith/_context.md` | Zenith, wellness, recovery |
| **Client C** | `clients/apex/_context.md` | Apex, chiropractic, health |

Now when you mention "Acme," the AI loads that client's context. Mention "Zenith," it loads a different one.

The architecture scales to as many domains as you need. Ten domains. Twenty. Fifty.

The limit isn't the architecture. It's how much context you're willing to maintain.

Automatic vs. Manual Loading

Keyword-based routing is automatic. The AI detects the domain and loads the context without you asking.

But sometimes you want manual control. Maybe you're about to switch from work to business and you want to explicitly load the business context first.

You can do that with a command: "Load business context."

The AI reads business/_context.md and confirms it's loaded. Now everything you ask will run through that lens until you switch to a different domain.

Most people don't need manual control. Automatic routing handles 95% of cases. But the option exists.

Context Files as Living Documents

Your _context.md files aren't static. They update as your domains change.

You hire someone new at work? Add them to work/_context.md. You finish a client project? Update business/_context.md. You change your budget structure? Update personal/_context.md.

The AI can help. After a session where something important changes, you can ask: "Update the context file with today's changes."

The AI reads the session log, identifies what changed, and updates the _context.md file. Now next time you come back, the context is current.

This is how AI memory compounds. Every session makes the context richer. Every update makes the next session smoother.

Why This Beats Single-File Context

Single-file context forces you to load everything every time. The AI has to parse through work stuff to answer personal questions. It has to sort through client A to find client B.

Multi-domain architecture keeps things lean. The AI only loads what it needs. Faster. Cleaner. No risk of cross-contamination.

It's the difference between a filing cabinet with one drawer and a filing cabinet with 20 labeled drawers. Both hold the same stuff. One is easier to search.

Implementation: Start With Root + Two Domains

You don't need to architect ten domains on day one. Start simple:

1. Create root CLAUDE.md with a routing table
2. Create two domain folders (work and personal, or business and personal)
3. Write a _context.md file for each domain
4. Test it—ask questions using different keywords and confirm the AI loads the right context

Once that works, add a third domain. Then a fourth. Build it out as your needs grow.

The architecture is flexible. You're not locked into a structure on day one.

The Result: AI That Knows Where It Is

With multi-domain architecture, the AI doesn't just remember about you. It remembers where you are.

Work mode has work rules. Business mode has business rules. Personal mode has personal rules.

No more "which one did you mean?" No more mixed-up references. No more explaining the same context twice.

The AI knows which drawer to open. And it opens the right one every time.