Build Intelligence Systems
Design guidance, decision trees, and code patterns for implementing the Cormorant Foraging framework.
How to Use the Framework
Step 1: Identify Your Primary Dimension
Ask yourself:
- Is time the enemy? (urgent decisions) → Sound
- Do relationships matter most? (structural complexity) → Space
- Is continuity critical? (memory across sessions) → Time
Step 2: Choose a Natural Metaphor
Pick a metaphor from nature that embodies your dimension:
Sound examples:
Chirping, howling, echolocation, alarm bells
Space examples:
Perching, nesting, web-building, hive architecture
Time examples:
Wakes, footprints, growth rings, geological layers
Step 3: Define Observable Properties
List what you can measure:
Database row count (observable)
"Good design" (subjective - avoid)
User action timestamp (observable)
"User will quit" (speculation - avoid)
Step 4: Design Your Scoring Method
Match your formula to your dimension:
Sound → Additive:
Score = Factor1×W1 + Factor2×W2 + ...Space → Multiplicative:
Score = (Dim1 × Dim2 × Dim3) / 100Time → Exponential:
Score = Base × e^(-time/decay)Which Dimension Do You Need?
"I need to make fast decisions under time pressure"
→ Sound Dimension
Examples: Trading, emergency response, waiver wire
Pattern: ChirpIQX (additive scoring, urgency tiers)
"I need to understand complex structure and relationships"
→ Space Dimension
Examples: Database schema, code architecture, network topology
Pattern: PerchIQX (ICE scoring, multiplicative)
"I need memory and continuity across time"
→ Time Dimension
Examples: Chatbots, version control, session management
Pattern: WakeIQX (causal chains, exponential decay)
Code Templates
TypeScript patterns for each dimension (adaptable to other languages):
Sound Dimension: Additive Scoring
interface SignalFactors {
recent: number // 0-10 scale
projected: number // 0-10 scale
opportunity: number // 0-10 scale
risk: number // 0-10 scale
}
class SoundIntelligence {
calculateUrgencyScore(factors: SignalFactors): number {
return (
factors.recent * 0.40 +
factors.projected * 0.30 +
factors.opportunity * 0.20 -
factors.risk * 0.10
)
}
categorize(score: number): string {
if (score >= 8.0) return 'CRITICAL'
if (score >= 6.0) return 'HIGH'
if (score >= 4.0) return 'MEDIUM'
return 'LOW'
}
}Space Dimension: Multiplicative Scoring
interface DimensionalFactors {
insight: number // 0-10 scale
context: number // 0-10 scale
execution: number // 0-10 scale
}
class SpaceIntelligence {
calculateICEScore(factors: DimensionalFactors): number {
return (factors.insight * factors.context * factors.execution) / 100
}
prioritize(score: number): string {
if (score >= 4.0) return 'HIGH'
if (score >= 2.0) return 'MEDIUM'
return 'LOW'
}
}Time Dimension: Exponential Decay
interface ContextItem {
timestamp: Date
baseRelevance: number // 0-1 scale
halfLife: number // Hours until 50% decay
}
class TimeIntelligence {
calculateRelevance(item: ContextItem, currentTime: Date): number {
const ageInHours =
(currentTime.getTime() - item.timestamp.getTime()) / (1000 * 60 * 60)
const temporalDecay = Math.exp(-ageInHours / item.halfLife)
return item.baseRelevance * temporalDecay
}
}Common Pitfalls
❌ Forcing a Dimension
Don't shoehorn your problem into a dimension it doesn't fit:
Wrong: "I'll use Space (PerchIQX) because it's database-related"
Right: "I'll use Sound (ChirpIQX) because urgency is primary"
❌ Mixing Scoring Methods
Don't combine additive and multiplicative in same formula:
Wrong: Score = (A × B) + (C × 0.4)
Right: Pick one: A + B + C OR (A × B × C) / 100
❌ Speculating Beyond Observables
Don't include unmeasurable factors:
Wrong: talent_factor = assessIntangibles(player)
Right: performance_factor = player.stats.pointsPerGame