Theme

Local-first agent framework

Relurpify

LLM coding agents that work in your real workspace — governed, sandboxed, and replayable end to end.
Read the docs GitHub

Relurpify is a local-first agent framework written in Go. It runs LLM-driven coding agents against your real workspace, and the tools stay yours — inspectable, stoppable, and fully under your control. No opaque model calls you cannot see, replay, and pin. No telemetry phoning home. Just you, your machine, and an LLM that works for you — not the other way around.

Every rung of the ladder is explicit: context is compiled into a deterministic artifact with a digest, a token budget, and provenance; every action passes a policy engine, a human-approval gate, and a sandboxed execution chain before it reaches your machine; memory persists as provenance-tracked knowledge chunks; and behavior is pinned by record/replay tapes and conformance suites. The model proposes, the framework disposes — the model never touches your machine directly.

The built-in coding agent is Euclo. The terminal UI is relurpish.

# Download

Build from source — you need Go 1.26+ and a container runtime (Docker, plus gVisor runsc for the default sandbox backend):

Clone and build the relurpish TUI

git clone https://github.com/lexbity/relurpify && cd relurpify && go build -o relurpish ./app/relurpish

No Docker or model backend handy? relurpish doctor --offline --fix followed by relurpish chat --offline exercises the full plumbing with a deterministic scripted model — for testing and CI, not real work.

# Try it

  1. Start a model backend

    Run ollama serve, then ollama pull gemma4:e4b in a second terminal — or use LM Studio, any OpenAI-compatible endpoint, or skip this entirely with the built-in offline scripted model.

  2. Initialize a workspace

    In the project directory you want the agent to work in, run the binary you just built: relurpish doctor. The first run materializes the starter configuration into relurpify_cfg/; git init in the workspace is recommended.

  3. Start the agent

    relurpish chat opens the governed coding agent in your terminal. When doctor ends with Result: ready, the workspace is good to go.

# Read the docs

The documentation set is short and normative:

Getting Started

From zero to a first completed agent turn: prerequisites, build, workspace init, model configuration.

The Relurpish Guide

Daily use of the relurpish TUI: the screen, the commands, approvals, and recipes.

Configuration

The complete relurpify_cfg/ reference: every file, its keys, and the validation rules.

Architecture

The system shape, the rules that hold it together, and what happens during boot and a turn.

The DSL references, testing guide, core glossary, and search live under the documentation index .

# The books

Relurpify is taught in three books. Pick the one that matches where you want to stand:

For builders

Agent Construction with Relurpify

Forge a new kind of worker in Go — a critic paradigm declared in the framework’s own DSL and proved at every test layer, shaped into a contribution you could merge.
For maintainers

Relurpic Internals

Walk the building itself: the machine-checked architecture, the governance engine, the sandbox, and the knowledge substrate — ending in your first PR.

# What it offers

Governed execution

Every model action is a capability with declared trust and effect classes; writes and risky steps pause for human approval in the default governed mode.

Sandboxed commands

Agent commands run in a container through gVisor or Docker — workspace mounted, network isolated by default.

Deterministic routing

A keyword classifier scores each instruction into intent families and picks a thoughtrecipe or capability deterministically: same input, same route.

Thoughtrecipes

Declarative .erpe workflows — trigger, tool scope, steps, captures — that you author and pin.

Compiled context

Retrieval, trust filtering, and token budgeting run deterministically over a knowledge-chunk memory graph; every compilation is recorded and replayable.

Characterizable

YAML-driven agent tests with outcome and security assertions, LLM record/replay tapes, golden files, and conformance suites treat agent behavior as something you can pin and regression-test.

# Get involved

Ride along on GitHub

Relurpify is solo-maintained, pre-1.0, and moving fast. Issues and pull requests are welcome — contributor PRs need a Signed-off-by trailer (DCO) and pass the enforced architecture gates. Browse the documentation to learn the system, or read the contributing guide for the workflow.
Relurpify on GitHub Contributing guide