ia-framework

Hierarchical Context Loading: Why Progressive Disclosure Beats Monolithic Prompts

A deep dive into the Intelligence Adjacent framework - from hierarchical context loading to VPS-deployed security tools. Every component explained.

Chris Groves

Chris Groves

— 3 min read
Cyberpunk anime: A figure navigates hierarchical tiers of floating knowledge - navigation, agents, and skills - pulling only needed context from the void

What if your AI assistant never forgot what it was doing?

Every session starts from zero. You explain context, re-establish methodology, reload mental models. The AI has capability—it just lacks scaffolding to use it consistently.

That's what Intelligence Adjacent solves. Following Anthropic's research on building effective agents, the solution is better orchestration—not bigger models.

The Problem Nobody Talks About

You're five hours into a penetration test. You've documented findings, established patterns, built momentum. Then you close the session.

Tomorrow:

You: "Continue the Acme pentest"
AI: "I'd be happy to help! What's the scope?"

All context—gone.

This isn't an intelligence problem. It's an architecture problem. And the solution isn't a smarter model. It's better scaffolding.

The Solution: Hierarchical Context Loading

Think of it like a professional library. The card catalog (root CLAUDE.md) tells you where to find things. The section (agent) gives you the right domain. The book (skill) contains the actual methodology.

You don't load the entire library at once. You navigate to what you need.

User: "Run a pentest"
     ↓
CLAUDE.md (~150 lines)
     "Security work → security agent"
     ↓
agents/security.md (~150 lines)
     "Pentest → security-testing skill"
     ↓
skills/security-testing/SKILL.md (~500 lines)
     Complete methodology, tools, workflows

Total context loaded: ~800 lines instead of 8,000.
Token savings: 90%+

The Four Components

The framework has four layers, each with a specific job:

1. Root CLAUDE.md (Navigation)

Under 150 lines. Answers one question: "Where do I go next?"

Contains agent routing rules, critical requirements, directory map. Nothing else. No methodologies, no tool lists, no templates.

Read more: CLAUDE.md Deep Dive (coming soon)

2. Agents (Identity)

Thin wrappers—each under 150 lines (pre-commit hook enforced).

Define identity, communication style, skill routing. When the security agent needs pentest methodology, it loads the skill. When it needs code review patterns, different skill.

Multiple agents can share skills. Update methodology once, all benefit.

Read more: Intelligence Adjacent Agent Architecture

3. Skills (Intelligence)

This is where expertise lives. Each skill is a complete project:

  • SKILL.md - Decision tree and routing (~500 lines max)
  • reference/ - Frameworks loaded on-demand (PTES, OWASP, NIST)
  • workflows/ - Step-by-step procedures
  • scripts/ - Executable tools

Skills span domains: security testing, code review, threat intel, blog writing, job analysis, legal compliance.

Read more: Skills System Deep Dive

4. Servers (Force Multipliers)

VPS-hosted security tools with Python wrappers. The pattern:

  1. Agent calls nmap(target)
  2. SSH to VPS → Docker exec → Tool runs
  3. Full output saved locally
  4. Parsed summary returned (~150 tokens)

Result: 95% token reduction. Evidence preserved. Agent gets enough context to decide, full details available when needed.

Read more: VPS Server Tools Deep Dive

What Makes This Different

File-based everything. Version controlled, diff-able, editor-agnostic. No databases, no external dependencies.

Strict line limits. CLAUDE.md under 150 lines. Agents under 150. Skills under 500. Without limits, entropy wins.

Pre-commit enforcement. You can't accidentally bloat files, commit credentials, or break standards. Hooks catch it before it merges.

Multi-model architecture. Claude Sonnet for complex work. Haiku for routing (80% cheaper). Grok for QA (different perspective). Right model for each job.

The Commands That Tie It Together

Type /pentest and the system:

  1. Prompts for target and scope
  2. Routes to security agent + security-testing skill
  3. Creates engagement directory structure
  4. Executes phased methodology
  5. Produces professional deliverables

Commands exist across domains: /code-review, /job-analysis, /write, /risk-assessment. Guided workflows that make expertise accessible.

Read more: Slash Commands Deep Dive

Try It Yourself

# Clone
git clone https://github.com/notchrisgroves/ia-framework.git

# Install (creates ~/.claude symlink)
./setup/install.sh

# Configure API keys
echo "OPENROUTER_API_KEY=sk-or-..." >> ~/.claude/.env

# Start
claude

# Run a command
/pentest

VPS deployment is optional. The framework works without it—you just won't have security tool wrappers.

The Philosophy

Intelligence Adjacent means AI that works alongside human intelligence, not in place of it.

The framework provides context, methodology, tools, and memory. You bring judgment.

The goal isn't replacing expertise. It's making expertise accessible.

A nonprofit that can't afford consultants can deploy this themselves. A developer learning security can use Mentor mode to understand methodology while doing real work. A solo consultant can multiply capacity without hiring.

Orchestration over intelligence. Scaffolding over smarts. Augmentation over automation.

That's the IA framework.

Deep Dive Series

This overview scratches the surface. For complete implementation details:

  1. Slash Commands Deep Dive - Template-driven command system
  2. Agent Architecture Deep Dive - Multi-layer routing
  3. Skills System Deep Dive - Progressive context loading
  4. VPS Server Tools Deep Dive - 95% token efficiency

Sources

Framework & Architecture

Claude Code Integration

Infrastructure

Read more