Self-hosted AI engineering workspace

Your autonomous AI engineering team.

Reevkohur is a personal, self-hosted workspace where you describe outcomes, AI agents plan, test, build and review the work in your real repositories, and you supervise the decisions and accept the evidence.

Say it REEV-KOH-ur. The name is a made-up blend inspired by the Irish ríomh (computing) and comhar (cooperation): computers and people working together.

How it works

From a rough idea to a reviewed pull request

Agents do the work in order. You step in at the points that matter: approving the plan, answering questions about risky steps, and accepting the result.

  1. You

    Brainstorm on a board

    Sticky notes, diagrams and screenshots, with service cards pointing at your repositories.

  2. AI

    Ideas become feature proposals

    Each one assigned to the right repository, with the reason, and split across services when needed.

  3. Planning agent

    A plan you approve

    Acceptance criteria, the test command and dependent tasks. Approve it, or reject it with a note.

  4. Test agent

    Tests come first

    Tests are written from the acceptance criteria before the code exists, then protected.

  5. Development agent

    Implementation

    Each task runs in an isolated branch, is validated by the plan’s test command and committed when it passes.

  6. Review + Security

    Independent checks

    Two agents that never saw the work in progress check the result. Blocking findings get fixed.

  7. You

    Accept the evidence

    One package: criteria with evidence, test results, findings, scan, cost and rollback steps.

  8. Reevkohur

    Pull request and CI

    The branch is pushed, a GitHub pull request is opened and its CI checks are tracked.

You your decisionAgent AI does the workOutlined steps wait for your approval.

Features

Everything between the idea and the merge

Boards

Think on a whiteboard, then turn it into features

Boards is a whiteboard for the thinking before the building. It saves as you go.

  • Sticky notes, text, shapes and labelled arrows for diagrams, frames to group ideas, and freehand drawing.
  • Paste, drag in or upload screenshots.
  • Service cards map each part of your system to a repository your runner can reach.
  • Turn into features reads the whole board or a selection, screenshots included, and proposes features. Each names its repository and why, and an idea that spans services is split into linked proposals with dependencies.

Agents with guardrails

The model proposes. Deterministic code decides.

Every tool call an agent makes goes through a fixed policy that answers allow, ask or deny. Prompt text cannot change it.

  • Routine work, like reading, searching, ordinary file edits and running tests, goes ahead. Other commands wait for you in one Inbox, where you can allow one once or from now on.
  • High-impact commands such as git push, terraform apply and rm -r are always asked one at a time. A short list is blocked outright.
  • Agents cannot change the independent tests without your approval.

Evidence, not code review

Accept a result you can check

When the work is done you get an evidence package on the feature page and in the Inbox, with anything unresolved first.

  • Each acceptance criterion, met or not, with the evidence.
  • Test results re-run by Reevkohur on the final commit.
  • Review and Security findings, plus an automated scan of the diff for secrets and dependency changes.
  • Model cost and rollback steps.

Kanban board and execution history

Tasks move through columns with each agent's live status. Every attempt keeps its own transcript. A failed attempt is retried with the failure output, and after three tries the task is blocked until you look at it.

Pull requests and CI

Accepting pushes the branch (never forced) and opens a GitHub pull request whose description is the evidence package. Reevkohur tracks the CI checks, and you can merge from the UI once they pass.

Your models, your choice

Run the agents on Claude through the Anthropic API, or on your GitHub Copilot subscription. Either way, every tool call goes through the same policy, and costs are tracked per agent and per feature.

Runs where your code is

A local runner executes commands only in the folders you allow. It connects outward, so it opens no ports, and it strips cloud credentials from command environments. Reevkohur is self-hosted, and your data stays in your own database.

runner your machine outbound reevkohur your database

Benefits

Built for a solo developer or a small team

  • Ship more of your ideas

    Hand over a described outcome and let the agents plan, test and build it, without sitting over every line as it is written.

  • Review outcomes, not diffs

    Judge the work by its acceptance criteria, test results and findings. The diff is still there when you want it.

  • Stay in control of anything risky

    Commands outside the plan, changes to protected tests and high-impact commands wait for your answer. Pushing and merging happen only after you accept.

  • Nothing lands without you

    Every feature works on its own branch in an isolated worktree, so your own checkout is never touched.

  • Know what each feature cost

    Model cost is tracked per agent and per feature, and shown in the evidence before you accept.

Status

A personal project in active development

Reevkohur is built and used by one developer, and it changes often. The chat assistant, the feature workflow with its Kanban board, independent review and pull request delivery, Boards and the GitHub Copilot provider work today. Hosted, multi-runner scaling is in progress. There is no cloud service to sign up for: you run it yourself.