Technical Architecture

How HUB builds: systems, protocols, and philosophy

Overview

This is how HUB works technically—the architecture, tools, and principles behind our Human × AI collaboration.

For developers, engineers, and the technically curious.

Core Architecture

The Stack

Foundation Layer:

AI Models: Claude (Anthropic), GPT (OpenAI), Gemini (Google)
Protocols: Model Context Protocol (MCP), Agent-to-Agent (A2A)
Infrastructure: Cloud-based, distributed, scalable

Application Layer:

Multi-Agent Systems: Specialized Curators working collaboratively
Content Systems: GitBook, CMS, publishing workflows
Design Systems: Component libraries, design tokens
Data Layer: Vector databases (RAG), structured data (Schema.org)

Interface Layer:

Web: hub.curations.org, curationsla.com
Tools: Custom interfaces for specific workflows
APIs: Integration points for external systems

Multi-Agent Architecture

The Curator Network

How The Curators work together:

[User Request]
    ↓
[Orchestration Layer]
    ↓
[Curator Selection & Routing]
    ↓
[Individual Curators]
    ↓
[Collaboration & Synthesis]
    ↓
[Output to User]

Example Flow:

User: “Help me build a brand identity for a community project”
Orchestrator: Routes to Strategy → Design → Content → Ethics Curators
Strategy Curator: Develops positioning framework
Design Curator: Creates visual identity based on strategy
Content Curator: Develops messaging aligned with visual identity
Ethics Curator: Audits for potential issues
Synthesis: All outputs combined into cohesive deliverable

Implementation

System Prompts: Each Curator is defined by a specialized system prompt that includes:

Domain expertise
Personality traits
Ethical guidelines
Collaboration protocols
Output formats

Context Management: Using techniques from Context Manipulation:

Hierarchical context compression
Semantic anchoring
Cross-Curator state sharing
Efficient token usage

Collaboration Patterns:

Sequential: Curator A → Curator B → Curator C
Parallel: Multiple Curators work simultaneously, then synthesize
Iterative: Curators refine each other’s work through multiple passes

RAG Systems

Knowledge Architecture

Vector Databases:

Embeddings of HUB frameworks, documentation, case studies
Enables semantic search and retrieval
Powers context-aware responses

Structured Data:

Schema.org markup for machine readability
Metadata for content organization
Taxonomy for knowledge categorization

Implementation:

User Query
    ↓
Vector Search (semantic similarity)
    ↓
Retrieve Relevant Context
    ↓
Augment AI Prompt with Context
    ↓
Generate Response

Why this matters:

AI responses grounded in HUB knowledge
Consistency across different interactions
Ability to cite sources and provide evidence
Scalable knowledge management

Content Systems

GitBook Integration

Architecture:

GitHub Repository (source of truth)
    ↓
.gitbook.yaml (configuration)
    ↓
GitBook Platform (rendering & hosting)
    ↓
hub.curations.org (public access)

Workflow:

Content authored in Markdown
Committed to GitHub
Auto-synced to GitBook
Published to hub.curations.org

Benefits:

Version control (git history)
Collaborative editing
Markdown simplicity
Auto-deployment
Search and navigation built-in

Markdown + Enhancements

Standard Markdown:

Headings, lists, code blocks, links
Tables, blockquotes, emphasis
Clean, semantic, readable

GitBook Enhancements:

Hints and callouts
Tabs and expandable sections
Embedded media
Interactive elements

Custom Patterns:

Easter eggs (HTML comments)
Progressive disclosure
Hidden layers for advanced users

API & Integration Layer

Model Context Protocol (MCP)

What it is: A protocol for AI models to access external context and tools.

How HUB uses it:

Curators can access external data sources
Integration with specialized tools
Consistent context across model providers

Learn more in the Cookbook →

Agent-to-Agent Protocol (A2A)

What it is: A protocol for AI agents to communicate and collaborate.

How HUB uses it:

Curators exchange information
Collaborative workflows
Distributed intelligence

Learn more in the Cookbook →

Ethical Architecture

Principles in Code

Transparency:

All system prompts documented
AI interactions clearly labeled
Processes explained openly

Human Oversight:

Humans make final decisions
AI supports, doesn’t replace
Override mechanisms built-in

Privacy & Security:

No unnecessary data collection
Minimal tracking
User data protected
Open about what we collect and why

Accessibility:

Semantic HTML
ARIA labels
Keyboard navigation
Screen reader compatibility

Implementation Patterns

Consent-First:

// Don't do this
autoSubmitToAI(userData);

// Do this
if (userConsent.grantedForAI) {
  submitToAI(userData);
} else {
  processWithoutAI(userData);
}

Transparent AI:

// Mark AI-generated content
<div class="ai-generated">
  <span class="ai-badge">AI-assisted</span>
  {content}
</div>

Graceful Degradation:

// AI fails? System still works
try {
  result = await aiProcess(input);
} catch (error) {
  result = fallbackProcess(input);
  logError(error, 'AI_FAILURE');
}

Development Practices

Open Source Philosophy

What we open source:

Frameworks and methodologies
Prompt templates and Curator definitions
Design systems and component libraries
Documentation and learning materials

What we keep private:

Client work (unless agreed otherwise)
Proprietary implementations for specific clients
Sensitive configurations and keys

How to contribute: Get Involved →

Version Control

Git Workflow:

main branch: production-ready
Feature branches: feature/[name]
Descriptive commit messages
Pull requests for review

Semantic Versioning:

MAJOR.MINOR.PATCH (e.g., 1.2.3)
MAJOR: Breaking changes
MINOR: New features (backward compatible)
PATCH: Bug fixes

Tools & Technologies

Core Technologies

AI & ML:

Claude (Anthropic) - Primary reasoning model
GPT-4/4.5 (OpenAI) - Complementary capabilities
Gemini (Google) - Specific use cases
Custom fine-tuning (when needed)

Backend:

Node.js - Application logic
Python - Data processing, ML workflows
Serverless functions - Scalable compute

Frontend:

React/Next.js - Web applications
Tailwind CSS - Styling
Markdown - Content authoring

Data:

Vector databases (Pinecone, Weaviate) - RAG systems
PostgreSQL - Structured data
Redis - Caching

Infrastructure:

Vercel - Web hosting
AWS/GCP - Cloud services
GitHub - Version control & CI/CD

Development Tools

Code:

VS Code / Cursor - IDEs
GitHub Copilot - AI code assistance
ESLint/Prettier - Code quality

Design:

Figma - Interface design
Tailwind - CSS framework
Design tokens - Theming

Collaboration:

GitHub - Code & docs
Linear - Project management
Slack - Communication

Performance & Scalability

Optimization Strategies

Token Efficiency:

Context compression techniques
Hierarchical information architecture
Semantic caching
Prompt optimization

Caching:

Frequent queries cached
Vector embeddings reused
Static content CDN-served
Smart invalidation

Async Processing:

Long-running tasks queued
Background processing
Progressive enhancement
Graceful loading states

Security

Best Practices

API Keys & Secrets:

Environment variables (never committed)
Rotation policies
Least privilege access
Encrypted at rest

User Data:

Minimal collection
Encrypted transmission (HTTPS)
Secure storage
Clear retention policies

AI Safety:

Input validation
Output filtering
Rate limiting
Abuse detection

Monitoring & Observability

What We Track

System Health:

API response times
Error rates
Token usage
System availability

User Experience:

Page load times
Interaction patterns (anonymous)
Feature usage
Error encounters

AI Performance:

Response quality (sampled)
Curator effectiveness
Collaboration success rates
Token efficiency

Tools

Error tracking: Sentry
Analytics: Plausible (privacy-first)
Logging: CloudWatch / GCP Logs
Uptime monitoring: Checkly

Deployment

CI/CD Pipeline

Code Commit (GitHub)
    ↓
Automated Tests (Jest, Playwright)
    ↓
Build (Next.js, Tailwind)
    ↓
Deploy (Vercel, staging)
    ↓
Manual Approval
    ↓
Deploy (Vercel, production)

Environments:

Development: Local machines
Staging: Pre-production testing
Production: hub.curations.org, curationsla.com

Future Architecture

Roadmap

Short-term (3-6 months):

Enhanced Curator collaboration protocols
Improved RAG performance
Youth Curator platform launch
CurationsLA beta

Mid-term (6-12 months):

Multi-modal Curators (beyond text)
Real-time collaboration features
Advanced personalization (privacy-preserving)
Mobile applications

Long-term (1-2 years):

Federated Curator networks
Open Curator marketplace
Edge AI deployment
Fully decentralized knowledge graph

“Good architecture is invisible. Great architecture makes the impossible easy.”

That’s how HUB builds. 🏗️

← Back to Welcome