Kingsparrow
ensembly
Bot-native coordinator for live, correct status.
Agent stacks got good, fast. Grok Bot is smooth. What is still missing for one operator is pulse-accurate memory — and the hard layer above it: time travel through status, flying the landscape at any slice, and location coordination that never belongs on a public spacemap.
Problem
Big companies scale capture and inference — that is a feature. The remaining gap is not chat quality. It is pulse: live, precise memory of done, pending, and denied; spatial-temporal correctness so facts do not silently overwrite; and the same briefing loop costing tokens every morning.
When calendar, mail, and finance disagree, that is a data reconciliation problem — not a reason to distrust your bots. Multi-source conflict needs a coordinator, not a longer thread.
Harder still — and absent from typical agent product spacemaps — are time travel (what was true at any past moment, from the ledger, not chat scrollback), landscape at any slice (work, gates, places, clients as a living cut through time, not a static repo cluster map), and off-map location (where you actually are and what is next here, kept private, never a pin on a public building view).
Product
ensembly is a Bot-native coordinator under the clients you already use. One dedicated ensembler bot grows the kernel from a base seed and maintains it from usage — propose, human OK, PR or compiled workflow. Each operator's kernel is unique. Choose your clients: Grok Bot, other bots, laptop, CLI, future phone.
The bet is data correctness and pulse memory, not replacing the chat surface. The kernel is a time-addressable ledger — replay status, fly the landscape at any slice, hold private place+time facts off public maps. HITL gates mark irreversible acts you want to see clearly — trust and clarity, not a vote of no confidence in agents.
Kernel law: HITL / HOOTL
Automate the digital. Surface the physical. Wait only for permission. Make the truth playable.
HITL — human in the loop: optional verification and steering; joining is deliberate. HOOTL — human out of the loop: swarm on a directed graph toward the critical sequential path. The human is the scarce resource; the swarm clears digital thrash; physical pickups and irreversible gates wait for permission.
The kernel owns life-state, graph, critical path, HITL escalate, triggers, and message bus. Workers execute digital work. Game chrome is not the core. Remaining hard infrastructure: coordination, invoke/trigger, concurrent state, typed messaging.
Evals on verified artifacts — correct, effective (saves future energy), efficient (time/cost).
Thin structural swarm. Intelligence rented or open. Generational gain is harness and evals, not daily kernel evolution. Auth and physical gates never self-approve.
Complements Grok Bot and other clients — does not punch the bot ecosystem.
Interaction map
Always-on host
Operator computer runs the kernel, SQLite, local tools, optional local models for classify and conflict. Survives laptop sleep. One writer for live status.
Human laptop / phone
Approve and deny gates, next physical act, CLI or thin UI. A client on your terms — not a second source of truth.
Bot clients
Grok Bot and other bots stay first-class. Query runtime status for pulse-accurate answers. One ensembler bot coordinates and maintains the kernel from usage.
IDE / cloud coding agents
Propose code and chores. Kernel holds pending. Merge and approve is the emit step for irreversible digital work.
Local specialist tools
Finance kernel, notes, calendar, mail as sensors. ensembly reconciles status by time, place, and source — it does not become a bank or an inbox.
Local vs cloud models
Local for classify and cheap conflict. Cloud when the kernel cannot decide. Not an ensemble of every model on every fact.
Collaborator / export
What ships to others is hub law, typed IR, and HITL resume — never one operator's private persona.
Ledger & landscape
Time-addressable pulse: replay status at any past moment, fly work/gates/places/clients at any slice. Private location coordination stays on the ledger — off public portfolio spacemaps.
Use cases
Morning pulse
Operator and bots read one live status. No re-briefing the day from scratch.
Operator away
Kernel keeps running on the always-on host. Bot clients still query live gates and pending work.
Irreversible digital act
Send, pay, merge, submit — pending gate. Human approves on laptop or through a bot client that writes through the kernel.
Physical next act
Kernel surfaces the next body-world pickup. Bots handle digital coordination; you do the physical act.
Travel / two locations
Facts are time and location keyed. A remote calendar event does not overwrite a local errand.
Repeated ops
After N repeats of inbox triage or artifact cleanup, the ensembler bot proposes a compiled workflow. Human OKs. The briefing loop compiles instead of repeating.
Conflict
Calendar says free, mail says deadline, finance kernel says due. Kernel records the contradiction and applies a winner rule — explicit data, not an implicit merge.
Time travel
A gate was denied last week. A bot claims otherwise. Replay the ledger at that moment — done, pending, denied, conflicts — without scrolling chat or reconstructing the day in tokens.
Landscape at a slice
What was open before I approved the merge? Fly the landscape at t=before-gate — work, gates, places, clients as they were, not a static repo cluster map.
Off-map location
Next physical act depends on where the operator actually is. That coordination stays on the private ledger — never a pin on a public portfolio spacemap.
Prototype → product
The current ensembly repo is an honest prototype seed — Rust kernel, fact identity, HITL/HOOTL runtime. The ensembler bot maintains and extends it from usage. Browser game chrome, Node swarm control plane, and WASM world-sim as required host retire from the shell; the game can return later as one client.
Keep
- Rust
peram-kernel— control plane, HITL/HOOTL runtime, SQLite SoT - Fact identity — time, location, source, confidence
- Privacy default-deny; persona never uploaded
- Domain tools as sensors; ensembly reconciles status
- Evolution law — pattern → proposal → human OK → PR
Retire from shell
- Game of Peram as product chrome
- Node swarm as control plane
- WASM world-sim as required host
- Adversarial capture metaphor as the whole story
Why a company
Complement companies that scale fast at capture and inference. ensembly goes deep per human on correctness and pulse — and on the hard layer chat-scale products rarely productize: time-addressable ledger, slice flight through operator landscape, off-map location coordination. Exportable hub law, typed IR, reconciliation rules, usage-driven evolution via the ensembler bot.
Collaborators take the kernel shape and export law, not the founder's life data.
Ask
Collaborators
Kernel engineering, typed IR, local-first sync, HITL protocol design, time-addressable ledger, usage-driven evolution.
Investors
Seed conversation. No invented traction.
Building at Kingsparrow. Who is building it.