SmartupOS — The Laboratory¶
What is this?
A thesis without a laboratory is just philosophy. SmartupOS is the custom-built infrastructure where our sociotechnical experiment actually runs. This page provides a high-level map of the tools, servers, and scripts that make collective ownership, transparent ledgers, and democratic execution possible without traditional management.
Just give me the abstract
SmartupOS is a fully EU-sovereign, open-source, and self-hosted operating system for organizations. It uses Matrix/Element for communication, Forgejo for data storage, and a custom middleware bot (Engelbot) to bridge the two. By keeping the entire system text-based (Markdown and CSVs) and operating it through simple chat commands, we ensure that non-coders have exactly the same power and access as developers. There are no proprietary SaaS tools, no black-box algorithms, and zero distractions.
Where Theory Becomes Concrete¶
To test the Smartup Hypothesis, we needed a completely new kind of digital habitat. We could not build a radically transparent, collectively owned institution using proprietary, closed-source corporate tools optimized for top-down control.
We had to build our own lab.
SmartupOS is our institutional operating system. It is a transparent, forensic, and scalable framework designed to replace the traditional CEO with a unified, auditable ledger.
The Four Design Principles¶
Every piece of software in SmartupOS was chosen or built based on these strict constraints:
-
EU-Sovereign & Open Source --- We own our data. Everything is hosted on sovereign European infrastructure (Hetzner, Clever Cloud). There is zero reliance on proprietary American tech giants. If a tool isn't open-source, we don't use it.
-
Accessible to Non-Coders --- A democracy where only developers understand the tools is an oligarchy. Our system is operated entirely through natural language chat commands in Matrix. If you can send a text message, you can trigger complex ledger workflows.
-
Text-Based & Immutable --- There are no hidden databases. The entire system—every task, every objective, every owner profile, every financial transaction—is stored in plain text CSV files and Markdown wikis. It is universally readable and structurally immortal.
-
Zero Distractions --- Modern work tools are designed to hijack attention. SmartupOS is calm by design. We have stripped away notifications, algorithms, and endless feeds. You enter the workspace to execute, assess, and learn—nothing else.
The System Architecture¶
SmartupOS is divided into three distinct layers. The user never has to leave the "Front-Office" to interact with the complex machinery of the "Back-Office."
flowchart TB
subgraph Front["🌐 Front-Office (What you see)"]
M[Element / Matrix<br>Governance, Chat & Commands]
T[timeline0.org<br>Public Transparency Mirror]
end
subgraph Middleware["🤖 Middleware (The Engine)"]
E[Engelbot<br>TypeScript Matrix Client]
API[Toolbox API<br>Python Flask Server]
end
subgraph Back["🏗 Back-Office (The Ledger)"]
F[Forgejo<br>Git Repositories]
L[ -OSOT- <br>CSV Ledgers & Markdown Wikis]
end
subgraph External["💶 External Systems"]
OC[Open Collective EU<br>Treasury & Licenses]
end
OC -->|License Purchase| Front
M <-->|!commands & alerts| E
E <-->|HTTP POST| API
API <-->|Forgejo REST API<br>Optimistic Locking| F
F --- L
L -->|Auto-generates| TThe Laboratory Components¶
The infrastructure is broken down into four distinct pillars. Explore each one to understand how the technical subsystem supports the social subsystem.
Where we gather. Element (running on the Matrix protocol) is our communication and command layer. It replaces Slack, Discord, and email. This is where the General Forum debates, where Teams coordinate, and where workers tell the system what they are doing.
How we execute.
Engelbot is our custom-built AI assistant and workflow orchestrator. Living inside Element, it listens for commands (like !start_work or !claim_task), checks your permissions, and safely routes your actions to the ledger without you ever needing to write code.
Where truth lives.
Forgejo is a lightweight, open-source Git forge. It acts as our One Single Organ of Truth (OSOT). It houses the .csv ledgers that track ownership and currencies, and the .md wikis that hold our proposals, blueprints, and task handoff notes.
Where it runs. The invisible bedrock. This covers our sovereign hosting strategy on Hetzner, the Python Toolbox API that safely executes Engelbot's commands, and the automation pipelines that publish this very website.
The OSOT: Markdown First, CSV Second¶
The most radical technical decision in SmartupOS is our rejection of traditional relational databases (like PostgreSQL or MySQL) for our core state.
Instead, we use an Index-Content Architecture.
- The Index (CSV): Spreadsheets that hold truncated summaries, statuses, and IDs. This acts as the mathematical ledger.
- The Content (Markdown): Deep, human-readable wikis that contain the nuance—the "Why" and "How", the proposals, and the learning notes from work sessions.
View the Write Order (For Developers)
When a worker completes a task using !stop_work, the Python Toolbox executes this strict, immutable sequence:
- Markdown First: Updates the task's wiki file with the session duration and handoff notes.
- CSV Second: Appends a new row to
session_logs.csvand updates the status intask-budgets.csv. - Audit Trail Last: Writes the exact action, timestamp, and actor to
master-events.csv.
If the sequence fails midway, the system auto-recovers. There is no rollback, only forward-moving forensic truth.
The Result: Provable Institutional Trust
Because every action is triggered via chat, mediated by a bot, and logged in plain text git repositories, the entire organization becomes auditable by default. You don't need to trust the founders; you just need to read the ledger.
Ready to Contribute?¶
Join the Project
Become a Smartup Zero owner
Reach out
Contact the 3_1_leadership_team with questions or remarks
```