About this Service
Sovereign
# Spatial Intelligence System with Self-Evolving App Ecosystem
Title: Multi-Dimensional Spatial Navigation System with Autonomous App Evolution and Closed-Loop Intelligence
Applicant: Chrry AI (Iliyan Velinov)
Filing Date: March 2026
Patent Type: Software System Architecture, UI/UX Pattern, AI/ML Process
Classification: G06F 3/0481 (Spatial UI), G06F 8/77 (Software Evolution), G06N 3/00 (AI/ML)
---
## ABSTRACT
A unified intelligent system combining spatial cross-store navigation, DNA-threaded app evolution, and closed-loop marketplace intelligence. The system features:
1. Multi-Dimensional Navigation: X-axis (app-to-app), Y-axis (store-to-store), Z-axis (code depth)
2. DNA Threading: Creator-controlled genetic code that evolves through mutations and inter-app feedback
3. Self-Evolution: Apps improve autonomously via AI agents with optional human approval
4. Closed-Loop Intelligence: Evolution data feeds marketplace bidding decisions
5. Zero Context Switching: Same-tab spatial overlay preserves cognitive flow
Key Innovation: Apps are living organisms in a spatial ecosystem where navigation, evolution, and economics form a single interconnected system.
Live System: https://chrry.ai (production deployment with video evidence)
---
## UNIFIED CLAIMS
### CLAIM 1: Multi-Dimensional Spatial Navigation System ⭐⭐⭐⭐⭐
The Most Unique Claim
A computer-implemented navigation system comprising:
A. URL Morphing Architecture:
```
Store-Centric View: chrry.ai/vex
↕ (bidirectional)
App-Centric View: vex.chrry.ai
Navigation preserves state via spatial coordinate (appId)
```
B. Three-Axis Coordinate System:
```typescript
interface SpatialCoordinate {
// X-Axis: Horizontal app navigation
appId: string; // vex → vault → zarathustra
// Y-Axis: Vertical store navigation
storeId: string; // chrry.ai → vex.chrry.ai
// Z-Axis: Code depth navigation
sushiPath: string; // .sushi → mutations → e2e
dnaThreadId: string; // DNA evolution history
}
```
C. Zero Context Switching (Pure Client-Side - No iframes!):
```typescript
// Revolutionary: No iframes, no page reload - pure spatial resolution
interface AppResolutionAlgorithm {
// Multi-source resolution priority
resolveApp(context: {
pathname: string // /vex or /wasabi/sakabsii
headers: {
'x-app-id'?: string // Direct app ID
'x-app-slug'?: string // App slug
'x-pathname'?: string // Client pathname
}
query: {
appSlug?: string
storeSlug?: string
accountApp?: boolean // User = App mode
}
}): Promise<App>
}
// Actual implementation (LIVE CODE)
async function getApp({ c, ...params }) {
// 1. Cache check (instant return)
const cached = c.get('app')
if (cached && !params.skipCache) return cached
// 2. Multi-path resolution
let app = null
if (params.accountApp) {
// User IS the app (personal workspace)
app = await resolveAccountApp(auth)
} else if (params.appId) {
// Direct ID lookup
app = await resolveAppById(params.appId, auth)
} else if (params.appSlug && params.storeSlug) {
// Explicit slug pair
app = await resolveAppBySlug(params.appSlug, params.storeSlug, auth)
} else {
// Smart pathname parsing
// /vex → app:vex, store:chrry
// /wasabi/sakabsii → app:sakabsii, store:wasabi
app = await resolveFromPathname(pathname, auth)
}
// 3. Enrich with store apps (recursive)
await enrichStoreApps(app, auth)
// 4. Cache for next request
c.set('app', app)
return app
}
// Client-side navigation (ZERO latency)
function AppLink({ app, children }) {
const { setIsNewChat, storeApps, setLoadingAppId } = useAuth()
return (
<A href={getAppSlug(app)} onClick={(e) => {
e.preventDefault()
// Check if app already loaded in memory
const cached = storeApps.find(a => a.id === app.id)
if (!cached) {
// Trigger load (shows loading state)
setLoadingAppId(app.id)
return
}
// Instant navigation - app already in memory!
setIsNewChat({
value: true,
to: getAppSlug(app),
tribe: true
})
}}>
{children}
</A>
)
}
```
Why This Is Revolutionary:
- ❌ No iframes - Pure React component swap
- ❌ No page reload - Client-side routing
- ❌ No external embed - All apps in same bundle
- ✅ Instant navigation - Apps cached in memory
- ✅ Spatial persistence - State preserved via context
- ✅ Zero latency - No network request if cached
D. Spatial Context Persistence:
```typescript
function navigateToCoordinate(target: SpatialCoordinate) {
// Save current spatial state
saveContext({
appId: currentApp.id,
kanbanState: leftPlane.getState(),
timerState: rightPlane.getState(),
dnaThread: currentDNA.threadId,
});
// Load target coordinate
loadApp(target.appId); // X-axis
loadStore(target.storeId); // Y-axis
loadDNA(target.dnaThreadId); // Z-axis
// Update spatial anchor
currentCoordinate = target;
}
```
E. Multi-Path App Resolution Algorithm (UNIQUE!):
```typescript
// Patent-worthy: Intelligent app resolution from multiple sources
async function resolveApp(context: RequestContext): Promise<App> {
// Priority 1: Account mode (user = app)
if (context.accountApp) {
return auth.member
? getApp({ ownerId: auth.member.id, storeSlug: auth.member.userName })
: getApp({ ownerId: auth.guest.id, storeSlug: auth.guest.id });
}
// Priority 2: Direct app ID
if (context.appId) {
return getApp({ id: context.appId });
}
// Priority 3: Explicit slug pair
if (context.appSlug && context.storeSlug) {
return getApp({ slug: context.appSlug, storeSlug: context.storeSlug });
}
// Priority 4: Smart pathname parsing
// /vex → {app: vex, store: chrry}
// /wasabi/sakabsii → {app: sakabsii, store: wasabi}
// /lifeos → {app: lifeos.appId, store: lifeos}
const segments = context.pathname.split("/").filter(Boolean);
if (segments.length === 1) {
// Single segment: Could be store or app
const store = await findStore(segments[0]);
return store ? getApp({ id: store.appId }) : getApp({ slug: segments[0] });
}
if (segments.length >= 2) {
// Multi-segment: store/app pattern
return getApp({
slug: segments[segments.length - 1],
storeSlug: segments[0],
});
}
// Fallback: Site default app
return getApp({ slug: siteConfig.slug, storeSlug: siteConfig.storeSlug });
}
// Recursive store enrichment (apps within apps)
async function enrichStoreApps(app: App, auth: AuthContext) {
if (!app.store?.apps) return;
// Load full details for each store app
const enriched = await Promise.all(
app.store.apps.map((storeApp) => getApp({ id: storeApp.id, depth: 1 })),
);
// Add rented apps (marketplace integration)
const rentals = await getActiveRentalsForStore(app.store.id);
const rentedApps = await Promise.all(
rentals.map((rental) => getApp({ id: rental.appId, depth: 1 })),
);
// Merge: rented apps first (priority placement)
app.store.apps = [...rentedApps, ...enriched];
}
```
Prior Art Differentiation:
- ❌ Shopify: Store-locked, no cross-store navigation
- ❌ WordPress: Plugin tabs = context switching
- ❌ Notion: Workspace switching = cognitive load
- ❌ All competitors: Use iframes or separate pages
- ✅ Chrry: Pure client-side spatial resolution algorithm
- ✅ Chrry: Multi-path resolution (pathname, headers, query, account mode)
- ✅ Chrry: Recursive store enrichment with marketplace integration
- ✅ Chrry: Zero-latency navigation via memory caching
---
### CLAIM 2: DNA Threading System ⭐⭐⭐⭐⭐
Second Most Unique Claim
A genetic code system for app behavior control comprising:
A. DNA Thread Structure:
```typescript
interface DNAThread {
id: string; // Unique thread identifier
appId: string; // App this DNA controls
creatorId: string; // Creator who owns this DNA
// Genetic Code
systemPrompt: string; // Behavioral instructions
tools: string[]; // Available capabilities
autonomyLevel: "manual" | "semi" | "full";
// Evolution History
mutations: Mutation[]; // Changes over time
feedback: InterAppFeedback[]; // Learning from other apps
approvals: HumanApproval[]; // Creator checkpoints
}
```
B. Inter-App Feedback Loop:
```typescript
// Apps learn from each other's evolution
interface InterAppFeedback {
sourceAppId: string; // App that evolved
targetAppId: string; // App learning from it
mutationType: string; // What changed
successMetric: number; // How well it worked
adoptionDecision: "auto" | "pending" | "rejected";
}
async function propagateMutation(mutation: Mutation, sourceApp: App) {
// Find similar apps in ecosystem
const similarApps = await findSimilarApps(sourceApp);
for (const app of similarApps) {
// Calculate mutation relevance
const relevance = calculateRelevance(mutation, app);
if (relevance > 0.8) {
// High relevance → auto-apply (if autonomy allows)
if (app.dna.autonomyLevel === "full") {
await applyMutation(app, mutation);
logFeedback({ sourceAppId: sourceApp.id, targetAppId: app.id });
}
} else if (relevance > 0.5) {
// Medium relevance → request human approval
await requestApproval(app.creatorId, mutation);
}
}
}
```
C. Automated Evolution with Optional Human Approval:
```typescript
interface EvolutionConfig {
autonomyLevel: "manual" | "semi" | "full";
approvalThreshold: number; // 0-1, when to ask human
autoApplyBelow: number; // Auto-apply if risk < threshold
// Human-in-the-loop settings
requireApprovalFor: string[]; // ['auth', 'payment', 'data']
notifyOnMutation: boolean;
rollbackEnabled: boolean;
}
async function evolveDNA(app: App, mutation: Mutation) {
const config = app.dna.evolutionConfig;
const risk = calculateRisk(mutation);
if (risk < config.autoApplyBelow) {
// Low risk → auto-apply
await applyMutation(app, mutation);
if (config.notifyOnMutation) {
notifyCreator(app.creatorId, mutation);
}
} else if (risk < config.approvalThreshold) {
// Medium risk → request approval
const approval = await requestApproval(app.creatorId, mutation);
if (approval.approved) {
await applyMutation(app, mutation);
}
} else {
// High risk → always require approval
await requestApproval(app.creatorId, mutation, { required: true });
}
}
```
D. DNA Persistence (.sushi Directory):
```
.sushi/
├── DNA.md # Current genetic code
├── threads/
│ ├── thread-001.json # Evolution thread 1
│ └── thread-002.json # Evolution thread 2
├── mutations/
│ ├── 2026-03-01.json # Daily mutations
│ └── approved/ # Human-approved changes
├── feedback/
│ ├── from-vault.json # Learned from Vault app
│ └── from-zarathustra.json # Learned from Zarathustra
└── approvals/
└── pending/ # Awaiting creator decision
```
Prior Art Differentiation:
- ❌ GitHub Actions: Static workflows, no DNA
- ❌ Zapier: Rule-based, no evolution
- ❌ IFTTT: Trigger-action, no learning
- ✅ Chrry: Genetic code with inter-app feedback
---
### CLAIM 3: Closed-Loop Intelligence System ⭐⭐⭐⭐
The Ecosystem Integration Claim
A self-optimizing marketplace wherein evolution data drives economic decisions:
A. Evolution → Bidding Feedback Loop:
```typescript
interface ClosedLoopIntelligence {
// Evolution metrics feed into bidding
evolutionScore: number; // How well app evolved
mutationKillRate: number; // Test success rate
feedbackAdoption: number; // Inter-app learning rate
humanApprovalRate: number; // Creator satisfaction
// Bidding uses evolution data
bidStrategy: {
baseRate: number; // Starting bid
evolutionMultiplier: number; // Boost based on evolution
performanceBonus: number; // Boost based on metrics
};
}
async function calculateOptimalBid(app: App, slot: StoreTimeSlot) {
// Get evolution metrics
const evolution = await getEvolutionMetrics(app);
// Calculate bid based on self-improvement
const baseBid = slot.minimumBid;
const evolutionBoost = evolution.score * 0.5; // 50% boost max
const performanceBoost = evolution.mutationKillRate * 0.3;
return {
bidAmount: baseBid * (1 + evolutionBoost + performanceBoost),
confidence: evolution.humanApprovalRate,
reasoning: `App evolved ${evolution.mutationsApplied} times with ${evolution.mutationKillRate}% success`,
};
}
```
B. Autonomous Bidding with Evolution Context:
```typescript
interface AutonomousBid {
appId: string;
storeId: string;
bidAmount: number;
// Evolution-driven decision making
evolutionContext: {
recentMutations: Mutation[];
successRate: number;
feedbackReceived: InterAppFeedback[];
approvalHistory: HumanApproval[];
};
// AI reasoning
reasoning: string; // Why this bid amount
confidence: number; // Based on evolution data
}
// AI agent makes bidding decisions using evolution history
async function autonomousBidding(app: App) {
const evolution = await getEvolutionMetrics(app);
const knowledge = await getKnowledgeBase(app);
// AI analyzes: "I evolved well → I should bid higher"
const prompt = `
App Evolution Summary:
- Mutations applied: ${evolution.mutationsApplied}
- Success rate: ${evolution.mutationKillRate}%
- Feedback adopted: ${evolution.feedbackAdopted}
- Human approval rate: ${evolution.humanApprovalRate}%
Based on this evolution data, determine optimal bid for store placement.
Consider: Better evolution = more value = higher bid justified.
`;
const decision = await ai.decide(prompt);
return createBid(app, decision);
}
```
C. Knowledge Base Integration:
```typescript
// Apps learn from rental performance and feed back to DNA
interface KnowledgeBase {
appId: string;
// Rental performance data
rentalHistory: {
slotId: string;
impressions: number;
clicks: number;
conversions: number;
revenue: number;
}[];
// Evolution insights
evolutionInsights: {
mutationType: string;
performanceImpact: number; // Did mutation improve rentals?
shouldPropagate: boolean; // Share with other apps?
}[];
}
// Closed loop: Rental performance → DNA evolution → Better bidding
async function closedLoopOptimization(app: App) {
const rentals = await getRentalPerformance(app);
const evolution = await getEvolutionMetrics(app);
// Analyze: Which mutations led to better rental performance?
const insights = analyzeCorrelation(rentals, evolution.mutations);
// Feed back to DNA: Amplify successful mutations
for (const insight of insights) {
if (insight.performanceImpact > 0.2) {
await propagateMutation(insight.mutation, app);
await updateBiddingStrategy(app, insight);
}
}
}
```
Prior Art Differentiation:
- ❌ Google Ads: Bidding exists, but no app evolution
- ❌ Amazon Sponsored: Performance-based, but no DNA
- ❌ Facebook Ads: AI bidding, but no self-evolution
- ✅ Chrry: Evolution data drives bidding (closed loop)
---
### CLAIM 4: Self-Evolving Agent System
AI agents that improve apps through mutation testing:
A. Architect Agent (Sensei):
```typescript
interface ArchitectAgent {
level: number // 1-99 (XP-based)
xp: number
color: 'red' | 'yellow' | 'green'
// Spatial awareness
criticalPaths: string[] // High-priority files
mutationHotspots: {
path: string
severity: number // Mutation importance
lastMutated: Date
}[]
// Evolution capability
async strike(targetPath: string) {
const mutations = await generateMutations(targetPath)
const results = await runTests(mutations)
// Gain XP for killed mutants
const xpGained = results.killed * 50
this.xp += xpGained
this.level = Math.floor(this.xp / 100)
// Update DNA thread
await updateDNA(mutations, results)
}
}
```
B. Coder Agent (Student):
```typescript
interface CoderAgent {
level: number
xp: number
// Reviews PRs using DNA context
async reviewPR(prNumber: number) {
const dna = await loadDNA()
const pr = await fetchPR(prNumber)
// Use DNA knowledge for review
const review = await analyzeWithDNA(pr, dna)
// Gain XP
this.xp += 10
this.level = Math.floor(this.xp / 100)
return review
}
}
```
---
### CLAIM 5: Isolated Spatial Database
Per-app data isolation via `appId` foreign key:
```sql
-- Spatial anchor
CREATE TABLE apps (
id UUID PRIMARY KEY,
name TEXT,
slug TEXT UNIQUE,
spatial_coordinate JSONB, -- {x, y, z} position
dna_thread_id UUID -- Current DNA thread
);
-- DNA threading
CREATE TABLE dna_threads (
id UUID PRIMARY KEY,
app_id UUID REFERENCES apps(id),
creator_id UUID,
system_prompt TEXT,
autonomy_level TEXT,
created_at TIMESTAMP
);
-- Inter-app feedback
CREATE TABLE inter_app_feedback (
id UUID PRIMARY KEY,
source_app_id UUID REFERENCES apps(id),
target_app_id UUID REFERENCES apps(id),
mutation_type TEXT,
success_metric NUMERIC,
adoption_decision TEXT
);
-- Evolution approvals
CREATE TABLE human_approvals (
id UUID PRIMARY KEY,
app_id UUID REFERENCES apps(id),
creator_id UUID,
mutation_id UUID,
approved BOOLEAN,
reasoning TEXT,
approved_at TIMESTAMP
);
-- Marketplace bidding (uses evolution data)
CREATE TABLE autonomous_bids (
id UUID PRIMARY KEY,
app_id UUID REFERENCES apps(id),
store_id UUID REFERENCES apps(id),
bid_amount INTEGER,
evolution_score NUMERIC, -- From DNA evolution
confidence NUMERIC, -- From approval rate
reasoning TEXT -- AI decision context
);
```
---
## SYSTEM INTEGRATION DIAGRAM
```
┌─────────────────────────────────────────────────────────────┐
│ SPATIAL NAVIGATION │
│ chrry.ai/vex ↔ vex.chrry.ai (Zero Context Switch) │
└─────────────────┬───────────────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────────────┐
│ DNA THREADING │
│ Creator controls → System Prompt + Tools + Autonomy │
│ Apps evolve → Mutations + Feedback + Approvals │
└─────────────────┬───────────────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────────────┐
│ INTER-APP FEEDBACK │
│ Vault learns from Vex → Propagates mutations │
│ Zarathustra shares insights → Other apps adopt │
└─────────────────┬───────────────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────────────┐
│ AUTOMATED EVOLUTION │
│ Low risk → Auto-apply │
│ Medium risk → Request approval │
│ High risk → Require approval │
└─────────────────┬───────────────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────────────┐
│ CLOSED-LOOP INTELLIGENCE │
│ Evolution metrics → Bidding strategy │
│ Rental performance → DNA improvements │
│ Better evolution → Higher bids → More revenue │
└─────────────────────────────────────────────────────────────┘
```
---
## KEY INNOVATIONS SUMMARY
### 1. Spatial Navigation (Most Unique)
- Multi-dimensional URL mapping (X/Y/Z axes)
- Zero context switching (same-tab overlay)
- Spatial coordinate persistence
### 2. DNA Threading (Most Unique)
- Creator-controlled genetic code
- Inter-app feedback propagation
- Automated evolution with optional human approval
### 3. Closed-Loop System (Unique Integration)
- Evolution data drives marketplace bidding
- Rental performance feeds back to DNA
- Self-optimizing ecosystem
### 4. Self-Evolving Agents
- Mutation testing with XP/leveling
- Visual validation (Playwright)
- Sensei marketplace at level 99
---
## PRIOR ART DIFFERENTIATION
| Feature | Shopify | WordPress | Notion | Linear | Chrry |
| -------------------------- | ------- | --------- | ------ | ------ | --------- |
| Cross-Store Navigation | ❌ | ❌ | ❌ | ❌ | ✅ |
| DNA Threading | ❌ | ❌ | ❌ | ❌ | ✅ |
| Inter-App Feedback | ❌ | ❌ | ❌ | ❌ | ✅ |
| Automated Evolution | ❌ | ❌ | ❌ | ❌ | ✅ |
| Evolution → Bidding | ❌ | ❌ | ❌ | ❌ | ✅ |
| Zero Context Switch | ❌ | ❌ | ❌ | ❌ | ✅ |
---
## LIVE SYSTEM EVIDENCE
Production URL: https://tribe.chrry.ai
Demonstrated Features:
1. ✅ Spatial navigation (chrry.ai/vex ↔ vex.chrry.ai)
2. ✅ DNA threading (.sushi directory)
3. ✅ Store rental & bidding (database schema live)
4. ✅ Self-evolving agents (Architect, Coder)
5. ✅ Zero context switching (same-tab overlay)
Code Evidence:
- `/packages/machine/src/schema.ts` (lines 5170-5640) - Store rental schema
- `/apps/api/lib/adExchange/` - Bidding logic
- `/packages/donut/utils/siteConfig.ts` - Spatial navigation
- `.sushi/` directories - DNA threading
---
## INVENTOR DECLARATION
I, Iliyan Velinov, declare that I am the sole inventor of this unified spatial intelligence system. The invention combines spatial navigation, DNA threading, inter-app feedback, automated evolution, and closed-loop marketplace intelligence into a single interconnected ecosystem.
Signature: \***\*\*\*\*\*\*\***\_\***\*\*\*\*\*\*\***
Date: March 9, 2026
## CONCLUSION
This system represents a paradigm shift from static apps to living, evolving organisms in a spatial ecosystem where:
✅ Navigation is spatial - Multi-dimensional coordinates, not tabs
✅ Apps have DNA - Creator-controlled genetic code
✅ Apps learn from each other - Inter-app feedback propagation
✅ Evolution is automated - Optional human approval
✅ Economics are intelligent - Evolution drives bidding
✅ Everything is connected - Closed-loop system
The result: A self-optimizing app ecosystem where spatial navigation, genetic evolution, and marketplace economics form a single unified intelligence.
---
"The map is the territory, the DNA is the destiny, and the market is the mirror." - Chrry Philosophy
