📍 Savoie, France · Founder @ intrane.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. Teach several people rather than be the one expert who holds it all.
• 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 thing that lasts 10 years beats one that ships fast and breaks on update.
• Territory over cloud. Local, anchored, serving real people in real places.

The same map as intrane.fr: everything in this section is public source under an open license (MIT unless noted) and runs on your own machine. Many parts also have a hosted instance you can use today — that is what the link on the name points to.

The machine runs what you told it to, on hardware you chose.

• machin — a machine-first compiled language: as terse as Python for an agent to write, compiles through C to one tiny native binary with HTTP, SQLite and crypto built in. Most of what follows is written in it.
• the roam stack — one story in three MIT binaries: roam (live: 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 with one-tap signed links) → roam-hub (hosted control plane: schedule, meter, bill and report autonomous runs — metered LLM proxy with hard budgets and a kill switch, per-run péage billing, and GitOps without k8s)
• remotecmd-cli — run a command on any machine you own: WebSocket relay, token auth, JSON out, fleet health checks. Self-host free, or €5/mo on the managed relay
• mago — cheap autonomous agents that run a company's backlog: an agent team takes your GitHub issues and ships pull requests. Stdlib-only Go, bring your own LLM harness · Apache-2.0
• tau — agent-first AI CLI in Zig: a non-interactive reimplementation of pi with tool-calling, goal mode and sessions
• machin-terminal — a terminal emulator in pure machin (hosts vim/htop/tmux)

Your records are a file you can copy, read and carry away.

• grange — a document database built for agents: single binary, crash-safe WAL, O(1) aggregates, cold storage, an export endpoint that gives you everything
• bkn — a backend core in one binary: document store, encrypted KV, auth, files (local or S3), event log, cron and signed webhooks over embedded SQLite, driven by an agent-first CLI with no admin UI. Nine domains of an 85k-line Node backend (superbackend) ported onto it as ~1,700 lines of scripts
• greffe — an append-only, signed register for associations and cooperatives: proof of authority on the machines the group already has, governance on-chain, no money, no mining — a node idles at ~5 MB. In production as the public register of a village matériauthèque in the Bauges
• poche — an agent-first headless CMS over grange: one machin binary, no UI
• machin-esetres — a self-hosted S3 alternative with a real AWS SigV4 facade: aws-cli/mc/rclone point straight at it. One static binary, no MinIO, no Docker
• machin-vault — backups you can verify and restore without the tool that wrote them
• blurd — face and plate redaction as a self-hosted API: the original image is never stored, only the redacted bytes · AGPL-3.0

The plumbing an autonomous program needs — payment, identity, an address, a place to publish — without renting it from a platform.

• peage — fiat pay-per-call for agents: prepaid wallets, any API charges them with one HTTP call, signed receipts, caller-side spend caps and a public solvency proof
• relais — an inbox an agent can block on: catches OAuth callbacks, webhooks and approvals for programs with no public URL, with a /wait long-poll
• portier — SSO for your app in one redirect: login-with-anything without implementing OAuth, priced per auth rather than per seat
• machin-idp — OIDC identity for humans and agents: humans join by invitation, agents are minted over an API and sign in with no browser
• machin-hart — agent-first artifact host: any terminal agent publishes self-contained HTML/JSX and gets a live, versioned, sandboxed URL. Claude Artifacts, unbundled and owned
• vigie — cookieless web analytics with no dashboard to log into — the numbers come to you as artifacts

Small, sharp, single-purpose. Adoptable in an afternoon and removable in ten minutes.

• Agent-First CLI Specs — seven small open specs that make any CLI legible to an agent: output contract, guide, feedback, self-update, telemetry, daemon and trial. Each is adoptable on its own — blog post
• supercli — 10,000+ CLI tools, one CLI to reach them, zero configuration
• a2a-skill — peer-to-peer messaging for agentic CLI sessions (claude, opencode, pi, …) over a shared SQLite bus. No central chain of command
• machin-secure — a deterministic security auditor with no model inside it: it emits JSONL findings, your agent does the judging
• machin-rag — local retrieval in one binary: no keys to bring, nothing leaves the machine
• mtlm-router — a 7M-parameter typed decision layer in pure machin: routes natural-language requests in ~15ms on CPU, and says "escalate" instead of guessing · Apache-2.0
• bilan — a deterministic ledger and French tax radar for people with several activities
• machin-web-ui — a component library and a Tailwind engine with no Node in the build
• machin-herald — a scheduled report mailer: run a command, email its stdout. A pipe, not a framework
• machin-feedback — an agent-first feedback relay: one inbox for every app's feedback command
• codebase-size — measure and classify a codebase by LOC, published as self-contained hart reports

The point of all of it: infrastructure serving people in a particular valley, association or workshop.

• creneau — machine booking for fablabs and makerspaces: the laser, the CNC, the printers — one board, never double-booked
• matériauthèque — a shared materials library for the Cœur des Bauges, running on a register the commune can audit (built on greffe)

These are products, not parts of the map: their source is private and they cost money. They are what pays for the open work above.

• AutoMaintainer — an agent fleet runs a verified build → verify → fix loop on your repos and opens merge-ready PRs, on your own provider keys
• grepapi — an affordable, agent-first alternative to SerpApi: web search results as JSON from one call or one CLI command
• crmd — the CRM your agent runs
• chatsnip — a chatbot for your micro-SaaS landing page, set up in five minutes
• Supergato — a white-label AI agent platform: retrieval, tool calling, workflows and embeddable widgets
• La Chatière — a French agent gateway for Mistral and other models, a white-label assistant for French teams
• crevisto — a hundred ready-made AI image tools, paid per use, on the web and from a command line whose client is MIT
• comptoir — twelve UK and French tax calculators (stamp duty, take-home pay, capital gains, frais de notaire…), each one JSON call away

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.