AI assistants today mostly mean chat. You write a prompt, get an answer, correct it, write another prompt. An hour later you have your result — and an hour of lost time, because you spent all of it at the keyboard, babysitting the agent.

We wanted something different: hand over the work, walk away, and come back to a finished result. And above all — be able to look back six months later and see exactly how it was made.

So we built Luper.

No chat. A brief.

You don't chat with Luper. You write it a brief — a plain markdown file: what you want, what should be produced, and how to tell it's done.

The whole loop is four steps: write your brief, hand it over with luper run my_brief.md, approve the contract Luper writes back with luper approve 0042-a3f1c2 — then walk away while the agents plan, execute, verify and ship.

From the brief, Luper writes a contract — its own version of the assignment, including how the result will be verified. You review it and approve it. That is the only moment in the whole process where you're needed.

Then the agents take over. They plan, work, verify and criticise — and when it's done, the task folder holds an artifact: a result that has been checked against the contract. Next to it sits the complete record: every prompt, every response, every verdict, every routing decision. Nothing is hidden.

Why we didn't use an off-the-shelf answer

The market has two answers to "I need an autonomous agent that delivers a structured deliverable."

Hosted SaaS. You upload your data somewhere else, you don't see the prompts, you can't change the routing, and the audit trail is whatever the vendor decided to expose. Fine if your work isn't sensitive. Useless if you have to defend the output to a client, a board — or yourself, six months from now.

Frameworks. LangGraph, CrewAI and friends give you a graph DSL, a state machine, a plugin system and a thousand abstractions for problems you don't have. The autonomy is real — but debugging a stuck run means reading framework internals you didn't write.

Luper is the third answer. It sits on top of CLIs you already have installed (claude, codex), under subscriptions you already pay for. No new accounts. No metered API spending. And the whole orchestrator is a single file you can read end to end.

Smallness is the point

Luper is roughly 8,000 lines of Python. That's not a work in progress — that's the point.

The orchestrator is a while loop with five branches. Not a state machine, not a graph.
The workflow is text: the phase sequence in markdown, the agent prompts in markdown, the output structure in JSON schemas. Edit a prompt, the next run uses it. No code change.
The cockpit is FastAPI + HTMX. No SPA, no JS framework.

The same job built on LangGraph + Postgres + a React frontend would be 50,000 lines that nobody can audit, debug, or fork in a weekend. You can read Luper in an afternoon. And that's the whole trick: you don't have to trust an agent whose code you know. You simply know what it does.

Your machine. Your data. Your audit.

Everything runs locally. The artifact sits in the task folder, next to llm_calls.jsonl and events.jsonl with the full trail. When someone asks you in six months how the analysis was made, you don't show them a chat screenshot — you open a file.

Luper is part of a small family of tools we're building under Zisky.ai: Saturnin (the orchestrator and personal-AI control plane) and WhispeRS (local meeting transcription). Same conventions, same stance: your machine, your data.

Try it

Luper is open source: github.com/Zisky-ai/Luper

Watch demo on YouTube: https://www.youtube.com/watch?v=PSIwy57rCuY

All you need is Python 3.12, git, and the claude and codex CLIs signed in. Clone it, write your first brief, approve the contract — and walk away.

No promises, no magic. Just a small harness you can read.