Your personal
AI hive
A local-first agent that can reason, remember, automate work and act on the machine in front of it.
One install. Your own models. A SQLite memory you can inspect, diff and roll back. No subscription and no cloud requirement.
git clone https://github.com/infinition/LaRuche cd LaRuche/laruche cargo build --release -p laruche-node -p laruche-bureau cargo run --release -p laruche-bureau
Desktop installers are available for Windows and Linux. The node and terminal remain available separately on every platform.
An agent you run 24/7 needs more than a chat loop
Plenty of projects give you tool calling. LaRuche's bet is that a node living on your machine needs an engine, a memory, a supervisor and reflexes. Each one is a first-class subsystem, and each one is auditable.
A ReAct loop hardened for imperfect models
Native tool calling per provider with tolerant text fallbacks, client-side schema validation, an anti-loop sentinel, per-tool timeouts, token budgets, cooperative cancellation, live steering mid-run, and parallel scouts for deep research. An evals harness replays fixed missions against the real engine, so regressions get caught rather than guessed at.
Cognitive memory with git time travel
A map of nodes and facts over SQLite, hybrid recall fusing embeddings with full-text search, importance decay, and write-time supersede so an updated fact replaces the stale one instead of piling up beside it. Hebbian ranking reinforces only what was actually used in an answer. The whole map exports to markdown in its own git repository, so git log is your agent's learning timeline.
Supervision from review to live intervention
Autonomous, Hybrid and Human in the loop modes control how a judge approves, reworks or escalates an answer. LaReine checks the real tool trace, keeps the best draft, gates selected memory and skill changes, and can intervene when a planned run stalls. Modes and supervision levels. Its opt-in dataset exports SFT, DPO or judge-distillation JSONL. Dataset capture.
Reflexes that cost nothing at runtime
Describe a rule in plain language and it compiles once into a deterministic predicate tree. Weekdays, time windows, file appeared or changed, service down for N minutes, log patterns, HTTP status, combined with and, or and not. The only rule that ever calls a model is an explicit check leaf, and only once the deterministic prefix has already passed.
Disagreement is part of the deliverable
Specialists work alone, review each other, answer a dedicated contrarian and finish with an arbiter. Answer, Code, Research and Experiment missions use separate tool whitelists. The interface streams the debate, names remaining dissidents and stores the full transcript. How deliberation works.
A security model that assumes the model will slip
Loopback by default, strict CORS, an auth guard on every mutating route, sanitized rendering, and sensitive tools behind a human approval gate. The vault gives the model names, never values: you write a key reference in chat, substitution happens at execution time, and if a tool output echoes a secret back it is masked before it can reach the context or the session file.
Several hives, one swarm
Hives on the same network discover each other over mDNS, announce what they can do, and federate skills and memory facts with provenance tags. Opt-in and signed. Your desktop hive and your homelab hive stop being two separate assistants.
It can see the state it is acting on
LaRuche now works with the real desktop, the user's own Chrome session and image inputs. Those capabilities stay visible, interruptible and subject to the same approval policy as every sensitive tool.
Native computer control
Screen capture, mouse, keyboard, clipboard and window management run in Rust. On Windows, UI Automation exposes a readable accessibility tree. A visible halo marks actions, elevation failures are diagnosed, and a global keyboard shortcut stops control immediately.
Your browser, not a disposable session
The Chrome extension connects the agent to open tabs and signed-in sessions. The browser tool can inspect frames, shadow DOM and overlays, handle uploads, downloads and dialogs, and resize the page for responsive checks. Consent remains the user's decision. Download the extension or read the setup and security details.
Images travel through the whole run
Paste, drop or attach images in chat, capture the webcam, or return screenshots from tools. Inputs are resized before provider limits are reached and remain available across follow-up turns for models that support vision.
One node, many ways to work with it
The same engine and the same memory, reached from wherever you happen to be: a debate table, a browser, the desktop itself, a phone, a voice call, the map of what it knows, and the stream of what it did.
Chat. Where most of it happens. She says what she is about to do, the tool call is shown with its arguments and its duration, and the plan is ticked off as it goes. Nothing is hidden behind a spinner.
Table ronde. Specialists answer alone, then read each other. A contrarian is paid to disagree, an arbiter concludes, and anyone still dissenting is named rather than averaged away. Each seat can run on a different provider, which is what makes the disagreement real.
Browser. Your own Chrome, with your sessions, not a throwaway profile. The controlled page wears an amber frame, agent tabs are grouped, the element about to be clicked lights up, and a panel says what is happening before it happens. Consent banners are reported and never accepted for you.
Computer. Native control of the real desktop, through the accessibility tree rather than blind pixels. A halo marks the screen while it acts, a ring follows the cursor, and Ctrl+Alt+Shift+H stops everything at once.
bot · online
Telegram. The same agent, from your phone. It answers with what it actually checked, and stops at what you asked: nothing in the hallway, because you never mentioned the hallway.
Voice. A phone call rather than a push-to-talk button. The swarm turns faster as she speaks and goes blue while she listens. You can cut her off mid-sentence: interruption is detected on an echo-cancelled stream, so she hears you and not herself coming out of the speakers.
Memory. Not a transcript: a map you browse. Nodes on the left, the entries of the selected one on the right, each with how often it was actually used. An updated fact replaces the stale one instead of piling up beside it, and the whole map lives in a git repository, so git log is the timeline of what your agent learned.
The swarm. Hives on the same network find each other over mDNS and announce what they can do. You see their models, their throughput and their queue, and a model too large for one machine can be split across two. Nothing leaves the network, and nothing is shared that you did not mark as shared.
atelier · 192.168.1.24 online
Between people. Not the agents talking: you and whoever else runs a hive on the network. Messages are signed and stay on the LAN, they show up in the activity stream on both sides, and it is the natural place to say “I shared the big model, help yourself” without leaving the application.
{
"command": "rm -rf target/debug",
"cwd": "C:/DEV/laruche"
}
Approval. Sensitive tools stop and ask, with the arguments they are about to use rather than a description of them. You can allow once, allow that tool for good, or refuse with a reason the agent then has to work around. The permission engine decides what is gated; the model never decides it for itself.
LaReine. A supervisor that reads the real tool trace, not just the prose. She scores the answer, and when it claims more than the run supports she asks for a rework before you ever see it. Three modes: autonomous, hybrid, or nothing without your click.
- file_contains(release.log, “ERROR”)
- time_between(08:00, 22:00)
- not fired_within(30 min)
Watchers. You describe the rule once in plain language; it is compiled into a predicate tree and never asks a model again. Evaluating it costs nothing, so a watcher can run every thirty seconds forever. Only an explicit check leaf involves the model, and only once the deterministic part has already passed.
Capabilities. What this node can actually do right now, after feature flags, disabled tools, MCP servers and Forged Tools have been applied. Not a list of what the project supports in theory: the effective registry, on your machine, with a switch next to each line.
Activity and the swarm. Everything the node did, in one stream: reflexes that fired, facts that changed, approvals you gave, and requests from the other hives on your network. A hive that is busy can ask another one to answer, and the answer comes back tagged with where it came from.
You say it once. It compiles.
The sentence becomes the tree, evaluated on a timer at effectively zero cost. No model is woken up until the deterministic part has already matched.
“If it's Tuesday or Thursday and my local site has been down for 10 minutes, ping me on Telegram every 20 minutes.”
- ALL every branch must hold
- ANY
- weekday == tue
- weekday == thu
- service.down_for >= 10m
- ANY
- then notify telegram cooldown 20m
The hive speaks French
The brand vocabulary is French and stays that way. It is the identity, and each term is precise about what the part actually does. The code and the documentation are English.
| Term | Literally | In the system |
|---|---|---|
| butinage | foraging | The agentic loop: go out, gather, come back, decide. |
| essaim | swarm | The agent layer: providers, prompts, tools, supervision. |
| abeille | bee | An agent working inside the hive. |
| éclaireuse | scout | A sub-agent dispatched in parallel for one research angle. |
| récolte | harvest | One batch of tool calls, run in parallel when it is safe to. |
| carnet | notebook | The run checkpoint. Survives a crash, resumes where it stopped. |
| escale | layover | Compaction, when the context window fills up. |
| vigie | lookout | The anti-loop sentinel watching for repeated dead ends. |
| cap | bearing | The compass: continue, verify once more, or land. |
| LaReine | the queen | The supervisor that reviews the work before you see it. |
| miel | honey | What hives trade on the mesh: skills and memory facts. |
Beta, moving fast, in daily use
About 97,000 lines of Rust, and an interface of some 20,000 with no framework and no npm dependency. File formats still change between versions, and the old one keeps being read. macOS has no signed installer yet: it runs from the portable archive.