Collaboration truth
Room-shared sequenced state and events. What happened, in what order, observed by all participants. The room's source of truth. Owned by the Director — the server-side sequencer that maintains authority over shared state.
Fireweed
The platform that builds the platform.
The same substrate that powers our products also powers how we build, coordinate, and operate the company itself. This isn't a cute recursion — it's the acid test.
Fireweed is the first plant to grow after a forest fire. It doesn't wait for perfect conditions. It grows in the ash, stabilizes the soil, and creates the conditions for everything that follows.
Chamaenerion angustifoliumThe acid test.
If the room protocol can't handle three engineers pair-programming with an AI co-developer and a CI/CD agent reporting build status, it also can't handle three friends shopping with a concierge agent and a brand specialist. The interaction patterns are structurally identical:
Multiple participants with different contexts, roles, and expertise. Multiple AI participants with different capabilities and authorities. Shared truth that everyone observes. Per-participant adaptive experience. Effects that are governed, approved, and traceable.
By building our own company — development workflow, operations, coordination, internal tools — on the same substrate we ship to consumers, we guarantee that the platform stays general. The moment Fireweed needs a capability that Wishflower doesn't, or vice versa, we extend the platform rather than fork it. Every product is a proof point. The platform gets stronger with every product.
If a capability, interaction pattern, or architectural concept cannot serve both our internal platform and our consumer product without forking, it does not belong in the kernel. It belongs in a product-level composition.
The substrate.
Fireweed is built on the foundational platform described in The Platform →: rooms as the universal interaction primitive, every participant — human or AI — as a first-class citizen, deep relational memory, governed authority, and products as compositions on the same kernel.
What this page covers is the technical architecture that makes that possible — and how we prove it by running ourselves on it.
Five kinds of truth.
"Truth" in this platform is not one thing. Conflating them is where architectural drift begins. Every design decision traces back to which truth it serves.
Domain truth
Products, code, tasks, calendars, external facts. Authoritative, cross-room. The world outside the room. Domain truth lives in domain services — search, product catalogs, code repositories — not in rooms. Rooms are the interaction primitive, not the storage primitive.
Memory truth
Durable remembered context with provenance and governance. Per-user, governed. What the system believes about you — preferences, patterns, relationships, dynamics. Inspectable, editable, forgettable. Every belief traceable to a specific moment.
Experience truth
What a participant is being shown right now. Per-user, per-session. Two people in the same room observe the same shared reality, rendered differently — each optimized for their context, their preferences, their device, their role. Shared truth with individual projection.
Audit truth
Why an action happened. What ran, what was approved, what was the context. Every effect traceable. Every decision explainable. The provenance chain that answers: who is acting, on whose behalf, for whose eyes, grounded in which truth, under which grant, with which provenance?
The harness architecture.
The most effective systems humanity has built are black boxes with explicit harnesses. Large language models. Self-driving systems. Biological evolution. Nobody fully understands the interior. The harness is what makes it safe, directed, and correctable.
Fireweed is a harness architecture. Five components — the same five that govern every working complex system.
Invariants
What the system must never violate. The boundary of the envelope. Everything inside is free to evolve — code, structure, approach, implementation. The invariants define the shape of what the platform can become. They don't prescribe how.
Intent interface
How you tell the system what you want. Mission, context, constraints, success criteria. Humans specify what and why. The system determines how. This holds for human users of products, for engineers writing effort briefs, and for agents receiving instructions. The same pattern at every level.
Evaluation
How you know it's working. Outcome measurement, not process inspection. Does the user feel known? Does the effort fulfill its intent? Did reality match the mission? Evaluation is always against intent, never against procedure.
Escalation
When the system must stop and ask. Autonomy within the envelope. Human confirmation at the edge. The boundary between "proceed" and "ask" is crisp, not fuzzy — and it's governed by policy, not by the agent's judgment about whether to bother you.
Rollback
Every state is derived. Every action is journaled. Every mutation is reversible. You don't need to understand why something went wrong. You need to undo it. The ability to rollback is what makes autonomy safe — because the cost of a mistake is bounded.
The platform evolves inside the harness. Products compose on the platform. The harness is what persists. Everything else is the current output.
Products are compositions.
Products on this platform are not separate applications with separate architectures. They are compositions: a specific combination of agent programs, capabilities, surfaces, and policies running on the universal kernel.
| Product | Composition |
|---|---|
| Wishflower | Shopping rooms + companion agent + product/search/context capabilities + brand agent slots + deep personal memory |
| Fireweed OS | Dev/ops rooms + co-developer agent + code/CI/CD/knowledge capabilities + service agents + system-of-work analytics |
| Your product | Your rooms + your agents + your capabilities + your policies. Same kernel. Same protocol. Same memory architecture. Different composition. |
Adding a new product means declaring four things: which agent programs, which capabilities they compose, which artifact types they produce, and which policies govern the space. The kernel doesn't change.
The stack.
language Rust kernel · TypeScript services · Protobuf contracts
build Bazel monorepo
infra GKE Autopilot · Firebase Auth · Cloud SQL · GCS
arch Hexagonal · ports and adapters at all boundaries
state Event-sourced · optimistic client updates · CAS
observe OpenTelemetry · correlation across every boundary
agents First-class room participants · not tools, citizens
memory Postgres + pgvector · GCS for immutable evidence
client Expo React Native · gRPC-Web + RESTWhat Fireweed proves.
Every day we use Fireweed to build Fireweed, we're testing the thesis:
Rooms work as the coordination primitive.
Multiple humans and AI agents collaborating on shared state — efforts, plans, signals, blockers — in real-time, from any device.
The protocol is domain-agnostic.
The Director that sequences shopping room events is the same Director that sequences development room events. No domain logic in the kernel.
Compositions scale.
Wishflower and Fireweed are different products with different agents, different surfaces, different policies — on the same substrate. Neither required forking the kernel.
The harness holds.
Agents operate autonomously within bounded envelopes. Invariants are never violated. Escalation is crisp. Rollback is always available. The system is correctable.
The human stays in the loop without being the bottleneck.
The projection layer translates machine-speed state into human-comprehensible interaction. You don't need to monitor every action. You need the right thing surfaced at the right moment with the right context for you to make the call.
The substrate for coherent AI.
We're building the foundation for AI products that are coherent with the individual — not the consensus. Fireweed is what makes that architecturally possible.
We're hiring. We're fundraising. We're shipping.