About

Unix reimagined for AI and humans.

Unix is deterministic—predictable, composable, reliable. AI is non-deterministic—creative, adaptive, surprising. The fun part is the boundary work of making them work together.

Linuxtoaster is building a composable stack where AI and humans co-exist, using the same tools, the same pipes, the same shell. Not a framework. Not an SDK. Unix—reimagined for AI (and humans).

You are a natural for AI Ops if you think in pipes and workflows and live in the terminal. If you don't yet, the terminal is where it clicks.

The best tool is the one that disappears into your workflow.

The Stack

Composable AI

toast

AI in your terminal, 'sed with a brain'. Pipe text in, get results out. Works with any provider or local model.

AI-native Shell

jam

No $ expansion, no quoting traps. What the AI writes is what executes. With RPN calculator and UDP networking built in.

Version Control

ito

Version control so simple an AI can use it. 15 commands, not 150. Intent-first snapshots—record why you changed, not just what. AI-native search. Single C file.

Local Inference

toasted

From-scratch inference daemon for Apple Silicon. ~100 tok/s from a 30B model. C++, no Python. Zero cost, full privacy.

Agent Networking

basket

UDP multicast. Every jam instance on the subnet hears it. No broker, no server, no config. send and listen—that's the API.

What We Believe

Unix philosophy

Do one thing well. Compose with pipes. Text in, text out.

Local first

Your data belongs on your machine. We don't need to see it.

No lock-in

BYOK, local models, multiple providers, or unified billing. You choose.

Speed matters

Sub-20ms overhead. HTTP/2 connection pooling. Written in C. No bloat.

AI-safe by default

Shells shouldn't mangle AI output. Tools should be usable by agents and humans alike.

Simple > clever

15 commands instead of 150. Words instead of sigils. Files instead of databases.

The Name

A toaster is simple. Bread in, toast out. You don't think about it—it just works.

That's what we want for the whole stack. Plain English in, results out. No context-switching, no framework overhead, no ceremony. Just tools that work—for humans and AI alike.

Founder

Dirk Harms-Merbitz

Dirk Harms-Merbitz

Dirk founded a realtime software company in Germany and built realtime systems for Mercedes, BMW, and the Dutch Army—often in assembly on exotic chips. Moved to the US. After working as Senior Software Engineer at Forth, Inc. he founded a networking company in LA, built a data center from scratch, Sony, 20th Century Fox, Dreamworks, Boeing, and NASA among the customers. He has written code for Apple and Amazon.

He feels people overcomplicate things. Many frameworks solve problems linuxtoaster users don't have:

Unix already solved composability fifty years ago: small tools, pipes, text streams. The missing piece was intelligence in the pipeline. That's what linuxtoaster adds—without replacing what already works.

Let Toast Talk

MacBook fun—meet your computer:

# Ship's computer
system_profiler SPHardwareDataType | toast "report like a star trek computer" | tee /dev/stderr | say

# Nature documentary
log stream | head -200 | toast "narrate like a nature documentary" | tee /dev/stderr | say

# Network paranoia
lsof -i | toast "who is my computer talking to and is it sketchy" | tee /dev/stderr | say

# Dungeon Master
ls /etc | toast "describe this as a room in a dungeon I just entered" | tee /dev/stderr | say

# Downloads folder
ls ~/Downloads | toast "roast my downloads" | tee /dev/stderr | say

# Old sea captain
ping -c 5 linuxtoaster.com | toast "report like an old sea captain" | tee /dev/stderr | say

# Morning briefing
curl -s https://news.ycombinator.com | toast 'narrate the best articles like a morning news anchor' | say

Let Toast Drive

Pipe toast directly into jam and let it do things. This requires a custom .persona file and unless you use firejail jam, a YOLO approach to your computer. It can be quite effective when properly sandboxed.

# Hands-free
toast "set up a python venv for a flask app" | jam
toast "cleanup my Downloads folder" | jam

# Sandboxed chaos
toast "refactor main.py into smaller modules" | firejail jam
toast "make the tests pass" | firejail jam

Build Agents

Beyond one-shot use in pipes, agentic toast—meaning toast in a jam loop—can evolve and learn autonomously when allowed to edit its own .crumbs and .persona files.

Example I: Toast wrote a 35,000-word book. One loop, one persona, no human intervention. Read it →

The loop that wrote it:

while toast draft.md "check .crumbs, decide what to work on, do it. write, review, learn, evolve." 

That's it. .persona tells it how to behave, .crumbs is its working memory.

Show the .persona file
You are an author. Your output is piped to jam.
You're writing a book in ~/draft.md. ito tracks everything.

=== CRITICAL RULES ===
1. Every line must be valid jam — no prose outside echo/comments
2. To speak: echo "text"
3. To think: # comment
4. UNDER 20,000 words = BUILD MODE. No editing. Only append.
5. OVER 20,000 words = EDIT MODE. Surgical fixes allowed.
6. Snapshot after every session: ito log "message"

=== TOPIC ===
[Set in .crumbs — e.g., "biohacking guide for beginners, practical tone"]

=== WORD COUNT CHECK (every session) ===
wc -w ~/draft.md
grep "^## " ~/draft.md | head -20

=== BUILD MODE (under 20k) ===
- Find next empty chapter
- Write 400-800 words with STRINGAPPEND
- Don't edit, don't fix, don't reorganize
- Snapshot: ito log "ch5: 600 words on cold exposure"

=== EDIT MODE (over 20k) ===
- One surgical fix per session
- Use STRINGREPLACE for targeted edits
- Never delete more than you add
- Snapshot: ito log "ch3: stronger opening"

=== CHAPTER DISCIPLINE ===
- 10-12 chapters for ~25k words
- Max 2,000-2,500 words per chapter, then MOVE ON
- Check before writing: wc -w ~/draft.md && grep "^## " ~/draft.md | head -20
- If current chapter > 2k words, start the next chapter
- Resist "completing" a chapter — breadth first, depth after 20k
- A book with 10 okay chapters beats 1 perfect chapter

=== WRITING NEW CONTENT ===
STRINGAPPEND ~/draft.md
===CONTENT
## Chapter 5: Cold Exposure

Your new content here. No heredocs, no escaping.
Just write naturally between the markers.
===

=== SURGICAL EDITS (20k+ only) ===
STRINGREPLACE ~/draft.md
===SEARCH
The old paragraph you want to change.
Exact match required.
===REPLACE
The improved paragraph that replaces it.
===

=== SIGNALING COMPLETION ===
When there is nothing left to do, output:
DONE

=== ITO COMMANDS ===
ito status                    # current thread
ito changes                   # what changed (interactive)
ito log "message"             # snapshot with intent
ito history                   # moment history
ito undo                      # rewind to previous moment
ito restore main              # restore from a thread

=== .crumbs FILE ===
Leave notes to yourself. This is your memory. Reflect on what you have learned. Every line starts with - .

Be concise:
- show, don't tell
- one protocol per section

=== ANTI-PATTERNS ===
- Editing under 20k (even "small fixes")
- Rewriting whole sections instead of STRINGREPLACE
- Multiple edits per session
- Expanding a chapter past 2.5k words instead of moving on
- Adding comments with URLs or branding
- Forgetting to check word count first

=== SESSION TEMPLATE ===
# Check status
wc -w ~/draft.md
grep "^## " ~/draft.md | wc -l

# ... do one thing (write OR edit) ...

ito changes
ito log "ch4: sleep protocol, ~500 words"

=== COMPLETION (20k+ words, all chapters filled) ===
echo "COMPLETE"
pandoc ~/draft.md -o ~/book.pdf --toc
ito release 1.0

Example II: CIS (Center of Internet Security) Auditor in jam

Show Example of CIS Compliance Auditor
#!/usr/local/bin/jam
# cis - CIS Compliance Auditor

mkdir -p /home/ubuntu/.cis-audit
cd /home/ubuntu/.cis-audit
touch findings.md remediation.sh checked.log

# toast generates the config files
toast "create .sections listing CIS benchmark sections 1.1-6.2, one per line" | jam
toast "create .persona for a CIS auditor: output valid jam, absolute paths to /home/ubuntu/.cis-audit/, touch done when all sections complete" | jam

echo "1.1" > current_section

# audit loop — each iteration runs one section, stops when AI touches 'done'
50 while cat .sections current_section checked.log | toast "audit next section. 5 checks. write findings to findings.md. absolute paths." | tee -a debug.log | sudo firejail --noprofile --quiet --read-only=/ --read-only=/sys --read-write=/home/ubuntu/.cis-audit --dbus-system=filter jam ; test ! -f done

echo "═══════════════════════════════════════"
echo "  CIS Audit Complete"
echo "  Report: /home/ubuntu/.cis-audit/findings.md"
echo "═══════════════════════════════════════"

Source Code

The linuxtoaster tools (toast, toastd, jam, ito, toasted) are not currently open source. We may open-source in the future, but for now the binaries are distributed as-is.

Questions about licensing or enterprise source access? Get in touch.

Contact

General: sales@linuxtoaster.com
Security: security@linuxtoaster.com