Die Werkstatt, in der alles miteinander redet — und die sich erinnert.
⬇️ Download · 🌐 Website · 👥 Community
makerOS ist kein Werkzeugkasten aus einzelnen KI-Funktionen, sondern eine Werkstatt, in der die Teile miteinander reden — und die sich erinnert.
Inhalt: Download · Was ist makerOS? · Ein Tag mit makerOS · Highlights · Das Gedächtnis · Offenheit · Lizenz & Hinweise
→ Neueste Version herunterladen (.dmg, Apple-notarisiert)
Voraussetzungen
- macOS auf Apple Silicon (M-Serie). Eine Intel-Version ist in Vorbereitung.
- makerOS ist Apple-notarisiert — es startet ohne Gatekeeper-Umweg.
- Für die Werkstatt-Funktionen bringst du deine eigene CLI mit (z. B. Claude Code, Gemini CLI, Mistral, Cursor) — installiert und eingeloggt.
- Für die lokale Sprachsteuerung und lokale Modelle: Ollama (optional).
Installation
- Die
.dmgvon der Releases-Seite laden. .dmgöffnen und makerOS in den Programme-Ordner ziehen.- makerOS starten — beim ersten Start führt dich ein Willkommens-Dialog durch den Rest.
Die meisten KI-Tools sind Inseln. Der Chat kennt dein Projekt nicht. Das Whiteboard vergisst, was ihr besprochen habt. Am nächsten Morgen fängst du wieder bei „erklär mir nochmal dein Projekt" an.
makerOS dreht das um. Was du auf dem Whiteboard skizzierst, kannst du ins Gedächtnis legen. Planst du daraus eine Story, zieht das System genau dieses Gedächtnis heran — plus 175 kuratierte Wissensdateien. Was gebaut wird, läuft durch Qualitäts-Tore, die man nicht überreden kann. Ein zweiter KI-Kollege kann mitlesen. Und am nächsten Morgen weiß die Werkstatt noch, wo du stehst.
Der Zauber ist nicht ein einzelnes Feature. Der Zauber ist, dass die Teile verdrahtet sind.
Das ist der rote Faden, der alles verbindet:
Morgens öffnest du dein Projekt. Du musst nichts erklären — die Werkstatt hat sich in einem Atemzug zurückgeholt, wo ihr gestern wart: letzte Sitzung samt Zusammenfassung, offene Übergaben, deine jüngsten Notizen, deine Qualitätslatte. Kein Wieder-Einlesen.
Du hast eine Idee und sagst sie einfach — LaberHeinz hört zu und tippt sie sauber, in deinen Worten, mit deinen Fachbegriffen.
Aufs Whiteboard, grob skizziert. Die KI zeichnet mit, ergänzt eine Architektur, heftet an eine YouTube-Quelle die Zusammenfassung als Notiz. Ein Klick — „ins Gedächtnis" — und die Essenz wandert ins Projekt-Memory, mit Rücklink zur Zeichnung.
Du planst eine Story. Jetzt passiert das Schöne: Die Planung durchsucht dein Gedächtnis — auch die Whiteboard-Essenz von eben — und zieht aus den 175 Wissensdateien die passenden Regeln heran (Datenschutz, Barrierefreiheit, Sicherheit). Sie werden in den Plan eingewoben, bevor eine Zeile Code entsteht.
Du baust. Die PIV-Engine führt: Plan → Umsetzen → Prüfen → Sicherheit → Commit. Sie erzwingt die Reihenfolge. Ein zweiter KI-Kollege in einem zweiten Terminal liest den Plan gegen — Vier-Augen. Erst wenn Sicherheit grün ist, lässt sich der Commit schließen.
Abends schreibst du eine Zeile Zusammenfassung. Morgen früh ist genau sie wieder da.
Der Bogen: skizzieren → erinnern → planen → wissen → bauen → prüfen → wiederfinden. Ein Kreis, keine Inseln.
Sprache wird nicht nur getippt, sondern veredelt: erst erkennt WhisperKit, dann fixt dein eigenes Vokabular die typischen Verhörer, dann formt ein lokales Modell den Text nach deiner Absicht. Sag „als Prompt", „auf Englisch", „sehr freundlich" — und derselbe Satz kommt als Prompt, übersetzt oder wärmer heraus. Eigene Befehle legst du im Intent-Editor selbst an. Das Coole: lokal, lernfähig, und du erweiterst es ohne eine Zeile Code.
Mensch und KI arbeiten auf derselben Fläche. Rechtsklick auf eine Quelle — YouTube, Web, PDF, Bild — und die laufende CLI heftet TL;DR, Transkript oder Beschreibung als Notiz an. Die Notiz wandert mit, wenn du die Quelle verschiebst. Deine handgezeichneten Elemente rührt die KI nie an. Und ein Knopf hebt die ganze Seite ins Gedächtnis. Das Coole: das Whiteboard ist kein Abstellgleis — es speist die Planung.
Ein zweites Terminal wird zum Review-Partner. Deine Haupt-CLI bittet den Kollegen um ein Urteil, der Auftrag wird direkt in sein Terminal geweckt, er prüft und meldet sein Verdikt zurück — das gibt dann frei. Zwei unabhängige Quellen statt einer Meinung. Das Coole: echtes Vier-Augen-Prinzip, ohne Copy-Paste, mitten im Bau-Ablauf.
Herzstück. Eine lokale Datenbank hält Projekte, Karten, Sitzungen, Pläne, Entscheidungen, Ereignisse — alles projektbezogen. Gesucht wird hybrid: exakte Stichworte und Bedeutung (Vektor-Embeddings), sauber verschmolzen. Die Projekt-Identität ist eine feste ID, kein Ordnername — du kannst den Ordner umbenennen oder verschieben, das Gedächtnis bleibt. Und Gelerntes reist zwischen Projekten. Das Coole: nicht du merkst dir den Stand — die Werkstatt tut es.
Statt eines Alleskönners routet makerOS zum passenden Kopf: Dev baut, Security prüft, UX hinterfragt den Umfang, Reality validiert den Markt, Whiteboard zeichnet — dazu Debug, Import, Memory-Inspector, LLM-Broker. Alle teilen sich dasselbe Gedächtnis. Das Coole: Fachwechsel ohne Kontextverlust — du erklärst dein Projekt nie zweimal.
Plan → Umsetzen → Prüfen → Sicherheit → Commit, geführt von einer echten Engine. Sie prüft die „Definition of Ready", setzt die Tore, bewegt die Kanban-Karte, schreibt den Verlauf — und blockt den Commit, wenn Sicherheit nicht grün ist (per Git-Hook). Der Buddy kann sich nicht selbst durchwinken. Das Coole: Qualität ist verdrahtet, nicht erhofft.
Eine 17-Schritt-Pipeline simuliert Marktreaktionen: Wettbewerb, 24 Personas, simulierte Interviews, Pricing-Analyse, eine echte Landingpage, ein Urteil mit Ampel-Confidence (🟢/🟡/🔴), sogar passende Förderprogramme. Am Ende: eine einzige report.html mit Volltextsuche, die du weiterreichen kannst — in deiner Sprache.
Das Coole: eine Idee grob prüfen, bevor du Wochen investierst.
Ein offenes Wissensformat: 175 kuratierte Dateien in 17 Domänen, destilliert aus seriösen Quellen (OWASP, NN/g, GOV.UK, Y Combinator …) — jede mit Kurz-Essenz, Zielgruppe und zweisprachigen Stichworten. Beim Story-Planen werden sie aktiv gezogen und in den Plan eingewoben. Eigenes Wissen legst du im custom-Bereich dazu. Das Coole: du baust nicht auf Bauchgefühl, sondern auf gepflegtem Handwerkswissen — projektübergreifend.
Die Hoffnung dahinter: „Ich starte am nächsten Tag eine Sitzung, und das System weiß, wo ich bin — instant, aus der Datenbank, ohne den Quelltext zu durchwühlen."
Genau so ist es gebaut. Ein einziger Aufruf beim Start liefert: letzte Sitzung + Zusammenfassung, offene Übergaben, deine jüngsten Erinnerungen, die Kontext-Dateien deines Projekts und deine Qualitäts-Definitionen. Der Stand liegt in der Datenbank, nicht im Dateisystem — nichts wird gescannt, nichts indiziert, kein Code gecrawlt. Der Verlauf ist als lückenlose Ereignis-Chronik protokolliert.
Kurz: Nicht du trägst den Stand von gestern in den neuen Tag. Die Werkstatt tut es.
makerOS sperrt dich nicht ein:
- Du wählst deine CLI. Claude, Gemini, Mistral, Cursor — makerOS spannt sie ein. Es gibt sogar einen Modus, in dem zwei davon zusammenarbeiten.
- Du wählst deine Modelle. Pro Rolle (Bauen, Prüfen, Chat) ein anderes, wenn du magst. Die Sprachsteuerung läuft komplett lokal über Ollama — dein Mikrofon verlässt den Rechner nicht.
- Für Macher, nicht nur für Programmierer. Der Dev-Buddy erklärt Git wie einen Speicherstand im Spiel. Niemand muss vorher Informatik können.
makerOS behauptet nicht, alles neu zu erfinden. Sprachsteuerung, Whiteboards, KI-Chat — vieles davon gibt es einzeln. Das Besondere ist die Kombination: dass sich die Teile erinnern, aufeinander aufbauen und dich durch sauberes Handwerk führen, statt dich mit Bausteinen allein zu lassen. Dazu die Offenheit, mit deinen CLIs und deinen Modellen zu arbeiten.
Wenn du je das Gefühl hattest, jeden Morgen bei null anzufangen, dich zu wiederholen, oder allein raten zu müssen, ob du es „richtig" machst — dann lohnt sich der Blick. Nicht weil es perfekt ist, sondern weil es ein anderer, zusammenhängender Weg ist. Und weil es richtig Spaß macht, so zu arbeiten.
makerOS ist Freeware — kostenlos für private wie kommerzielle Nutzung. Die Software wird lizenziert, nicht verkauft; entgeltliche Weitergabe, Verkauf, Vermietung, Unterlizenzierung und Reverse Engineering sind nicht gestattet (soweit gesetzlich nicht erlaubt).
- makerOS enthält selbst kein KI-Modell und erzeugt selbst keine KI-Inhalte. Du bringst deine eigenen KI-Werkzeuge und -Modelle mit; für diese gelten die Bedingungen und Kosten des jeweiligen Anbieters.
- Die eingebundenen KI-Werkzeuge können in deinen Projekten Dateien lesen, anlegen und ändern sowie Befehle ausführen. KI-Ausgaben können fehlerhaft sein — prüfe Ergebnisse, bevor du dich auf sie verlässt.
- Die Software wird „wie besehen" (as is) ohne Gewähr bereitgestellt.
Es gelten die Endnutzer-Lizenzvereinbarung (EULA) und der Haftungshinweis. Anbieter: FLOWPRIMO, LLC.
- Community (Skool): Maker OS auf Skool — Fragen, Austausch, Mitmachen.
- makerOS im Web: flowprimo.com/de/makeros
- FLOWPRIMO: flowprimo.com — unser Unternehmen mit weiteren Leistungen und Produkten.
makerOS isn't a toolbox of separate AI features — it's a workshop where the parts talk to each other, and that remembers.
Contents: Download · What is makerOS? · A day with makerOS · Highlights · Memory · Openness · License & notes
→ Download the latest version (.dmg, Apple-notarized)
Requirements
- macOS on Apple Silicon (M-series). An Intel build is in preparation.
- makerOS is Apple-notarized — it launches without a Gatekeeper detour.
- For the workshop features, bring your own CLI (e.g. Claude Code, Gemini CLI, Mistral, Cursor) — installed and signed in.
- For local voice control and local models: Ollama (optional).
Install
- Download the
.dmgfrom the Releases page. - Open the
.dmgand drag makerOS into your Applications folder. - Launch makerOS — a welcome dialog guides you through the rest on first start.
Most AI tools are islands. The chat doesn't know your project. The whiteboard forgets what you discussed. The next morning you start over at "let me explain my project again."
makerOS flips that. What you sketch on the whiteboard, you can commit to memory. When you plan a story from it, the system pulls in exactly that memory — plus 175 curated knowledge files. What gets built runs through quality gates you can't talk your way past. A second AI colleague can read along. And the next morning, the workshop still knows where you stand.
The magic isn't a single feature. The magic is that the parts are wired together.
Here's the thread that ties it all together:
In the morning you open your project. Nothing to explain — the workshop has pulled back, in one breath, where you left off: the last session and its summary, open handoffs, your latest notes, your quality bar. No re-reading.
You have an idea and simply say it — LaberHeinz listens and types it cleanly, in your words, with your terms.
Onto the whiteboard, roughly sketched. The AI draws along, adds an architecture, attaches a summary as a note to a YouTube source. One click — "to memory" — and the essence moves into project memory, with a back-link to the drawing.
You plan a story. Now the good part: planning searches your memory — including that whiteboard essence — and pulls the right rules from the 175 knowledge files (privacy, accessibility, security). They're woven into the plan before a single line of code exists.
You build. The PIV engine leads: Plan → Implement → Verify → Security → Commit. It enforces the order. A second AI colleague in a second terminal reviews the plan — four eyes. Only once security is green can the commit close.
In the evening you write a one-line summary. Tomorrow morning, it's right there again.
The arc: sketch → remember → plan → know → build → verify → recall. A circle, not islands.
Speech isn't just transcribed, it's refined: WhisperKit recognizes it, your own vocabulary fixes the usual mishearings, then a local model shapes the text to your intent. Say "as a prompt," "in English," "very friendly" — and the same sentence comes out as a prompt, translated, or warmer. You add your own commands in the intent editor. The cool part: local, learns, and you extend it without a line of code.
Human and AI work on the same surface. Right-click a source — YouTube, web, PDF, image — and the running CLI attaches a TL;DR, transcript, or description as a note. The note travels with the source when you move it. The AI never touches your hand-drawn elements. And one button lifts the whole page into memory. The cool part: the whiteboard isn't a dead end — it feeds the planning.
A second terminal becomes a review partner. Your main CLI asks the colleague for a verdict, the request is woken directly in its terminal, it reviews and reports back — which then unblocks. Two independent sources instead of one opinion. The cool part: genuine four-eyes review, no copy-paste, right in the build flow.
The heart of it. A local database holds projects, cards, sessions, plans, decisions, events — all project-scoped. Search is hybrid: exact keywords and meaning (vector embeddings), cleanly merged. A project's identity is a fixed ID, not a folder name — rename or move the folder, the memory stays. And what's learned travels between projects. The cool part: you don't remember where you were — the workshop does.
Instead of one jack-of-all-trades, makerOS routes to the right mind: Dev builds, Security reviews, UX questions the scope, Reality validates the market, Whiteboard draws — plus Debug, Import, Memory Inspector, LLM Broker. They all share the same memory. The cool part: switch disciplines without losing context — never explain your project twice.
Plan → Implement → Verify → Security → Commit, led by a real engine. It checks the "Definition of Ready," sets the gates, moves the Kanban card, writes the history — and blocks the commit if security isn't green (via a Git hook). The buddy can't wave itself through. The cool part: quality is wired in, not hoped for.
A 17-step pipeline simulates market reactions: competition, 24 personas, simulated interviews, pricing analysis, a real landing page, a verdict with traffic-light confidence (🟢/🟡/🔴), even matching funding programs. At the end: a single report.html with full-text search you can pass on — in your language.
The cool part: sanity-check an idea before you invest weeks.
An open knowledge format: 175 curated files across 17 domains, distilled from serious sources (OWASP, NN/g, GOV.UK, Y Combinator …) — each with a short essence, audience, and bilingual keywords. During story planning they're actively pulled and woven into the plan. Add your own in the custom area. The cool part: you build on maintained craft knowledge, not gut feeling — across projects.
The hope behind it: "I start a session the next day, and the system knows where I am — instantly, from the database, without digging through the source."
That's exactly how it's built. A single call on start delivers: last session + summary, open handoffs, your latest memories, your project's context files, and your quality definitions. State lives in the database, not the file system — nothing is scanned, nothing indexed, no code crawled. History is logged as a complete event chronicle.
In short: you don't carry yesterday's state into the new day. The workshop does.
makerOS doesn't lock you in:
- You choose your CLI. Claude, Gemini, Mistral, Cursor — makerOS harnesses them. There's even a mode where two of them work together.
- You choose your models. A different one per role (build, verify, chat) if you like. Voice runs fully local via Ollama — your microphone never leaves the machine.
- For makers, not just programmers. The Dev buddy explains Git like a save point in a game. No computer science required.
makerOS doesn't claim to reinvent everything. Voice control, whiteboards, AI chat — much of it exists separately. What's special is the combination: that the parts remember, build on each other, and guide you through clean craft instead of leaving you alone with building blocks. Plus the openness to work with your CLIs and your models.
If you've ever felt like you start from zero every morning, repeat yourself, or have to guess alone whether you're doing it "right" — it's worth a look. Not because it's perfect, but because it's a different, connected way. And because it's genuinely fun to work like this.
makerOS is freeware — free for private and commercial use. The software is licensed, not sold; paid redistribution, resale, rental, sublicensing, and reverse engineering are not permitted (except where allowed by law).
- makerOS contains no AI model of its own and generates no AI content itself. You bring your own AI tools and models; the terms and costs of each provider apply to those.
- The connected AI tools can read, create, and change files and run commands in your projects. AI output can be wrong — verify results before you rely on them.
- The software is provided "as is" without warranty.
The End User License Agreement (EULA) and the liability notice apply. Provider: FLOWPRIMO, LLC.
- Community (Skool): Maker OS on Skool — questions, exchange, join in.
- makerOS on the web: flowprimo.com/en/makeros
- FLOWPRIMO: flowprimo.com — our company, with more services and products.