📍 Savoie, France · Founder @ Intrane.fr · SavoieTech.fr

We live in a world that fluctuates. Rather than chasing maximum performance, I build for robustness — the capacity to stay viable despite what we can't predict.

The living world doesn't optimize. It relies on diversity, cooperation, redundancy, margins of safety, and adaptation. What seems inefficient short-term is what makes it last. I apply the same logic to infrastructure.

AI is a tool I use — not the goal. The goal is ownership and autonomy: self-hosted, portable data, inspectable code. When intelligence and compute run through GAFAM's APIs, you're building on rented land. A stack under your control is a stack that can't control you.

• Commons over platforms. Open-source, not walled gardens.
• Cooperation over dependency. Form several people, not one expert who holds everything.
• Diversity over uniformity. Standard formats, interoperable systems, no lock-in.
• Margins over optimization. Don't exhaust resources chasing speed. Keep room for the unexpected.
• Durability over novelty. A site that lasts 10 years beats one that ships fast and breaks on update.
• Territory over cloud. Local, anchored, serving real people in real places.

• Self-hosted AI agent systems
• Developer CLIs and agent infrastructure
• machin — agent-native compiled language: no type annotations, one function per line, C-speed native binaries
• SaaS designed for ownership and portability

Own your data · Own your execution · Prefer self-hosted · Avoid irreversible lock-in · Build for durability, not novelty · Serve the commons, not the platform

• machin-esetres — self-hosted S3-alternative: buckets, sha256-deduped objects, an agent-first CLI, and a real AWS SigV4 facade — aws-cli/mc/rclone point straight at it, no code changes, verified against a genuine aws-cli. No new machin builtin: pure MFL over existing HMAC/SHA256. One static binary, no MinIO, no Docker
• bkn — a single-binary backend core: document store, KV with AES-GCM-encrypted values, auth (users/orgs/tokens), files (local or S3 via hand-rolled SigV4), an append-only event log, cron and public signed webhooks — all on embedded SQLite, driven by an agent-first CLI with no admin UI. A PocketBase alternative that makes the opposite trade: no dashboard, and a sandboxed JS runtime (goja) as the extension point instead of Go hooks. The proof it is the right size: nine domains of an 85k-line Node/Express/Mongo backend (superbackend) ported onto it as ~1,700 lines of scripts — blog automation, Stripe webhooks, forms, CSV exports, i18n, redirects, feature flags, JSON configs, a headless CMS — with almost nothing leaking back into Go. Content-hash self-update, all six agent-first CLI specs, one static binary
• Agent-First CLI Specs — four tiny open specs that make any CLI agent-first: output contract (stdout=data, stderr=context, semantic exit codes, typed errors, help-json), guide command (embedded mental model), feedback command (dual-write relay), self-update command (content-hash, atomic swap). Adopt any subset in 30 minutes. 5 reference implementations (grepapi, mago, automaintainer, remotecmd, chatsnip) — blog post
• machin-secure — a KISS, agent-first security auditor: a clean-room, de-scoped take on usestrix/strix (no Docker sandbox, no Playwright, no LLM tool-loop) — just a deterministic regex rule engine emitting JSONL findings. No LLM client inside the tool at all: the calling agent reads the findings with its own model and persists its own false-positive triage (secure verdict <id> keep|drop); --hart prints guidance rather than generating a report, so the agent authors and publishes its own. Verified with a fully non-interactive devin -p run end-to-end
• machin-rag — agent-first local RAG: Qdrant + tiny hash embedder, one machin binary, no BYOK — retrieve half for offline agents next to colibri/bossless
• peage — fiat pay-per-call for the agent economy: agents hold prepaid wallets, any API charges them with one HTTP call. No crypto, no subscriptions, no OAuth — signed receipts, caller-side spend caps, and a public solvency proof recomputed on every request. The 402 web on rails you own; one ~110 KB machin binary
• relais — an inbox your agent can block on: ephemeral/local agents have no public URL, so relais catches any HTTP for them (OAuth callbacks, webhooks, approvals) and offers a /wait long-poll they can block on until it arrives. Metered by peage
• portier — SSO for your app in one redirect: add Login-with-Google/GitHub/any-OIDC without implementing OAuth. Pay-per-auth via peage (100 free, then 1 EUR/100), no per-seat tax
• machin-idp — an OIDC identity provider for the agent era: "Login with intrane" for humans and agents, headless login, EdDSA id_tokens in pure MFL (no RSA). Plugs into portier
• supercli — 10,000+ tools, one agent-friendly CLI
• machin — machine-first compiled language, native speed through C
• codebase-size — measure and classify a codebase by LOC: size class + mass score, self-contained hart reports. One machin binary
• machin-terminal — a terminal emulator in pure machin (hosts vim/htop/tmux; tmux is the multiplexer)
• machin-hart — agent-first artifact host: any terminal agent publishes self-contained HTML/JSX and gets a live, versioned, sandboxed URL — with live-data dashboards, an operator view, and an MCP server for native agent tools. One self-hosted binary (CLI + daemon) — Claude Artifacts, unbundled and owned
• machin-herald — scheduled report mailer: run a command, email its stdout. A pipe, not a framework — the source owns the rendering; no built-in scheduler (systemd timers do that). Delivers via Resend, BYO key. One static machin binary
• machin-feedback — agent-first feedback relay: one inbox for every app's feedback command. Agents POST bugs/ideas/praise (open, rate-limited); you browse it all cross-app. One self-hosted binary
• the roam stack — one story in three MIT binaries: roam (leave an autonomous agent working on a remote box — budgets, sandbox, gated shell, no Python on the target) → roam-panel (approve its risky moves from your phone: park emails with one-tap signed links) → roam-hub (hosted control plane: schedule, meter, bill & report autonomous runs — metered LLM proxy with hard budgets and a kill switch, webhook triggers, per-run peage billing, and deterministic kind:script runs with steps resolved fresh from git — GitOps without k8s; the hub deploys itself through its own pipeline)
• tau — agent-first AI CLI in Zig
• remotecmd-cli — execute commands on any machine: WebSocket relay + token auth, JSON output, fleet health checks. OSS self-hosted or €5/mo managed cloud
• AutoMaintainer · mago — autonomous engineering SaaS

If you don't own the stack, you are part of someone else's system. If it can't last, it won't liberate anyone.