Skip to content

The Laboratory: SmartupOS

TL;DR

SmartupOS is the apparatus that makes reproducible research into Collective IQ possible.

It is a completely sovereign, open-source operating system built specifically to test the Smartup Hypothesis. No proprietary tools. No hidden databases. No algorithms optimizing for attention. Just text-based ledgers, chat commands, and transparent automation.

Every component was chosen or built to directly support measurement of one or more CIQ indicators.

🟢 Status: Operational Apparatus — Core components are actively running and generating telemetry.

Why we built our own laboratory

To test the Smartup Hypothesis, we needed to create conditions where:

  • Ownership is genuinely shared
  • Governance is visibly transparent
  • Financial records are permanently auditable
  • No single person or algorithm makes decisions in secret
  • Any contributor can understand the entire system

You cannot achieve this using corporate tools.

So we built our own lab.

With on question in mind: What would an operating system for mission-driven communities look like if it needed to measure it's own Collective IQ?

System Architecture: Three Layers

SmartupOS is organized into three distinct layers. Users see only the front layer. The complexity exists but remains transparent to anyone who wants to understand it.

graph TB
    subgraph FRONT["Front-Office<br/>(User Interface)"]
        M["Element / Matrix<br/>Chat, governance,<br/>commands, discussion"]
        T["timeline0.org<br/>Public transparency<br/>mirror & documentation"]
    end

    subgraph MIDDLE["Middleware<br/>(The Engine)"]
        E["Engelbot<br/>Listens to commands<br/>Checks permissions<br/>Routes actions safely"]
        API["Toolbox API<br/>Executes ledger<br/>commands via Python<br/>scripts"]
    end

    subgraph BACK["Back-Office<br/>(The Ledger)"]
        F["Forgejo<br/>Git-based repository<br/>Version control<br/>Immutable history"]
        L["OSOT<br/>CSV Ledgers<br/>Markdown Wikis<br/>The source of truth"]
    end

    BACK -->|Auto-generates| T
    T -->|Mirrors| FRONT
    FRONT <-->|Commands| MIDDLE
    MIDDLE <-->|API Calls| BACK

The Key Insight: Data flows up from the ledger. Commands flow down from the chat.

A contributor never needs to touch a database. They send a chat command. The system checks permissions, updates the ledger, and publishes results back to the public mirror

The Four Components at a Glance

  • Element & Matrix

    Communication layer and command interface.

    Explore

  • Engelbot

    Middleware that converts chat commands into safe ledger operations.

    Explore

  • Forgejo

    Git-based ledger storing all organizational truth.

    Explore

  • Serverside Infrastructure

    Hosting, deployment, and operational backbone.

    Explore

The Four Components in Detail

Element / Matrix: The Public Interface

Purpose: Where people gather to work, decide, and coordinate.

Replaces: Slack, Discord, email—all in one open-source platform.

  • General Forum debates governance
  • Teams coordinate work
  • Workers report progress via commands
  • Decisions are made transparently
  • Middleware announces what just happened
Feature Slack Element/Matrix
Ownership Salesforce owns your data Open protocol, you own it
Hosting US corporate servers You control where it runs
Export Expensive, difficult Export anytime, trivial
Open Source Proprietary Fully open source
Federation No Yes—bridge to other networks
  • Perception (5): Visible discussion of threats/opportunities
  • Threat Recognition (6): Real-time awareness of external change
  • Coordination (8): Transparent communication, no silos

Deep dive

Engelbot: The Middleware

Purpose: Convert natural language commands into ledger mutations safely.

Replaces: Direct database access, terminal commands, developer-only operations.

Listens to commands like:

  • !claim_task 6_5_3_0
  • !start_work
  • !assess_work
  • !create_objective

When you send a command:

Command
  ↓
Permission Check
  ↓
Route to Toolbox API
  ↓
Python Script Executes
  ↓
Ledger Updated
  ↓
Report Back to Element

Without Engelbot, only developers could trigger ledger operations. That's oligarchy.

With Engelbot, anyone can execute complex operations using natural language.

The middleware is the democratization layer.

  • Integration (3): Non-technical people can participate in work allocation
  • Coordination (8): Reduced friction (no ticket forms, no email chains)
  • Self-Understanding (4): Process is visible, not hidden in code

Deep dive

Forgejo: The Ledger

Purpose: The source of truth for the entire organization.

Replaces: Traditional databases, accounting software, document management.

  • CSV Ledgers — Book of Owners, Task Budgets, Currency Transactions
  • Markdown Wikis — Objectives, Task descriptions, Governance decisions
  • Version History — Complete audit trail of every change
  • Access Controls — Permissions enforced via Git
Characteristic Traditional DB Git Repository
Immutability Requires careful backups Structural (every commit immutable)
Auditability Complex audit trails Built-in: every change is signed
Replication Requires mirroring Trivial: clone anywhere
Readable Binary files, requires tools Plain text, human-readable
Ownership Vendor lock-in risk Standard protocol, owned by you
  • Learning (1): Complete history of decisions and outcomes
  • Memory (2): Permanent, searchable institutional knowledge
  • Perception (5): Everything is visible, nothing is hidden
  • Threat Recognition (6): Historical patterns are searchable

Deep Dive

Serverside Infrastructure: The Invisible Bedrock

Purpose: Run the system reliably, transparently, and with zero vendor lock-in.

Replaces: Cloud platforms with corporate terms of service.

  • Toolbox API — Flask server executing Python scripts safely
  • Forgejo Instance — The Git repository
  • Element/Matrix Homeserver — Chat infrastructure
  • Deployment Pipelines — Auto-publish to timeline0.org
  • Primary: Hetzner (Germany, GDPR-compliant)
  • Backup: Clever Cloud (France, GDPR-compliant)
  • No US Cloud. No lock-in. Full sovereignty.
  • Autonomy (External): System is not dependent on any corporation
  • Resilience: Can be replicated anywhere, anytime
  • Trust: All infrastructure is auditable and open-source

Deep dive

The One Source of Truth: Index-Content Architecture

The most radical technical decision in SmartupOS is rejecting traditional relational databases in favor of Index-Content Architecture.

graph TB
    CONTENT["Content Layer<br/>(Markdown Files)<br/><br/>Narrative, reasoning,<br/>full context, learning<br/>Why was this decided?<br/>What did we learn?"]

    INDEX["Index Layer<br/>(CSV Files)<br/><br/>Truncated summaries,<br/>IDs, statuses,<br/>queryable records"]

    COMBINED["OSOT<br/>(One Single<br/>Organ of Truth)<br/><br/>Humans read Markdown.<br/>Machines read CSV.<br/>Both point to each other."]

    CONTENT --> COMBINED
    INDEX --> COMBINED

Why Split Into Two Layers?

What the system reads:

  • Fast, queryable
  • Machine-readable
  • The mathematical ledger
  • Stores decisions in form Engelbot can parse

Example: task-budgets.csv contains task ID, status, budget, assigned roles.

What humans understand:

  • Full reasoning and context
  • Why decisions were made
  • Learning from failed attempts
  • The institutional memory

Example: wiki/6_tasks/6_1_10_0.md contains work sessions, decisions, handoff notes.

The Write Order (Always)

Every mutation follows the same three-step sequence:

1. Write Markdown (narrative, context, reasoning)
   ↓
2. Write CSV (index row, machine-readable record)
   ↓
3. Write master-events.csv (audit trail)

This enforces that humans understand before machines act.

How This Architecture Enables the Experiment

graph TD
    HYP["Smartup Hypothesis<br/>Three interventions<br/>improve CIQ"]

    DESIGN["SmartupOS<br/>Apparatus Design"]

    SOCIAL["Accessible<br/>to non-coders<br/>✓ Supports<br/>democracy"]

    TECH["Text-based<br/>ledger<br/>✓ Supports<br/>memory +<br/>transparency"]

    EU["EU-Sovereign<br/>no vendor<br/>lock-in<br/>✓ Supports<br/>autonomy"]

    CALM["No algorithms<br/>no distractions<br/>✓ Supports<br/>focus"]

    MEASURE["Automatic<br/>Telemetry<br/>CIQ metrics<br/>measured<br/>without<br/>surveys"]

    HYP --> DESIGN

    SOCIAL --> MEASURE
    TECH --> MEASURE
    EU --> MEASURE
    CALM --> MEASURE

SmartupOS was not designed to be a general-purpose platform for anyone.

It was designed specifically to:

  • Enable democratic governance (non-coders can command the system)
  • Preserve institutional memory (everything is permanently recorded)
  • Maintain autonomy (completely sovereign, no external control)
  • Enable measurement (every action is logged and queryable)

This is what makes it a research apparatus rather than just software.

What SmartupOS Is NOT

SmartupOS is not a product for sale.

It is not a collaboration platform to compete with Slack.

It is not a startup toolkit.

SmartupOS is a laboratory apparatus—a carefully designed environment where a specific hypothesis can be tested under controlled conditions.

Like any laboratory equipment, it will evolve as we learn. But it exists for one purpose:

To enable reproducible research into Collective IQ.

Smartup Zero: The First Experiment Running in SmartupOS

graph LR
    RFC["RFC-001:<br/>Scientific<br/>Positioning"]

    HYP["The<br/>Hypothesis"]

    EXP["The<br/>Experiment"]

    SMARTUP["SmartupOS<br/>The<br/>Apparatus"]

    ZERO["Smartup Zero<br/>The Real<br/>Experiment"]

    TELEM["Machine<br/>Telemetry"]

    RFC --> HYP --> EXP --> SMARTUP --> ZERO --> TELEM
    TELEM -.->|Evidence| RFC

Smartup Zero is the experiment. SmartupOS is the apparatus. The experiment generates evidence. The apparatus enables reproducible evidence.

Current Implementation Status

Component Status Telemetry Notes
Element/Matrix ✅ Running Message logs, user activity Stable, used daily
Engelbot ✅ Running Command execution logs ~40 commands implemented
Forgejo ✅ Running Git commit history Ledger state frozen, auditable
Toolbox API ✅ Running Script execution logs Python scripts execute safely
OSOT Ledger ✅ Active CSV + Markdown sync Book of Owners, Task budgets live
timeline0.org ✅ Live Auto-generated mirrors Public transparency layer

What We're Measuring Right Now

  • ✓ Do commands execute as designed?
  • ✓ Does the ledger stay consistent?
  • ✓ Do the three-layer architecture boundaries hold?
  • ✓ Does the Index-Content sync work reliably?
  • ✓ Are metrics capturing what we expect?

Ways to Participate

  • Join Smartup Zero

    Become an participant in the first experiment.

    Explore

  • Start Your Own Smartup

    Take SmartupOS and run your own experiment.

    Learn How

  • Sponsor the Research

    Support Timeline0 and Smartup Zero through funding.

    Contribute

  • Collaborate as Researcher

    Work on the research programme itself.

    Get in Touch

References:

RFC-001: Scientific Positioning

The Experiment: How SmartupOS Enables Testing

Forgejo Documentation

Matrix Protocol

Element Client ```