Quests for teams of people and coding agents

Agents build.
You decide.

Filur turns rough ideas into quests with acceptance criteria, hands them to your coding agents and reviews every pull request against what you agreed. Where things stand writes itself. Nobody moves cards.

  • Claude Code, Codex and Cursor
  • Pull requests on GitHub
  • People merge

How it works

One loop, from a rough idea to a merged pull request.

People decide at every turn. Filur keeps the why, the what and the proof together, so agents build the right thing and everyone can tell when it's done.

  1. 01Shape

    Rough idea in. Quest out.

    Drop in a complaint, a thread or a hunch. Filur shapes it into a quest: who's affected, the evidence, what better looks like, and acceptance criteria that say when it's done.

    • Vague criteria get a nudge before anyone builds on them
    • Open questions come up early, not in review
    • Every suggestion is a proposal until someone applies it
  2. 02Agree

    Agree on what done means.

    Criteria are the contract between your team and your agents, and only people approve them. Open questions become decisions, with options, Filur's recommendation and an owner who makes the call.

    • A decision can add a criterion, so the call is checked in review
    • Domains pass their rules and standing decisions to every quest
    • The ledger keeps who decided what, and why
  3. 03Build

    Hand it to your coding agent.

    One context pack carries the quest, its criteria, the decisions to follow and the domain's rules to Claude Code, Codex or Cursor. The agent builds it and opens a pull request; link it to the quest and Filur takes it from there.

    • Over MCP, the CLI, the API or the SDK
    • Each agent signs in as itself
    • Pull requests that name the quest are first in line to link
  4. 04Review

    Every pull request, checked against the deal.

    Filur reviews each push criterion by criterion, with evidence, alongside reviewers for security, accessibility and risk. A criterion half-fills when an open pull request meets it, and fills in when it merges.

    • Fixed findings clear themselves on the next push
    • Several pull requests can each meet different criteria
    • Filur never merges. People do.

Everything else

The rest keeps itself up to date.

No boards to groom and no status to chase. Filur works out where things stand from what actually happened.

Status that writes itself

Stages come from criteria, decisions, reviews and merges. Filur writes where each quest stands, and rewrites it when something changes.

An inbox for what needs you

Decisions to make, criteria to approve, mentions and pull requests ready to merge. Not a feed of everything.

Decisions with receipts

A ledger of every call and why it was made. Standing decisions reach every quest in their domain.

Plans that forecast themselves

Projects and milestones on one timeline, with forecasts from real progress and weekly updates drafted for you.

Mention @Filur, get a proposal

Ask in any discussion. Filur proposes the change, and nothing happens until someone applies it. Then it's their change.

Live for people and agents

Every change from people and agents shows up as it happens, in the browser and on the command line.

For coding agents

First-class teammates. Never first in charge.

Filur doesn't bring a coding agent of its own. It gives the ones you already use a clear quest, a way in and a fair review.

  • Their own identity

    Each agent signs in through the browser as itself, and you can revoke it at any time.

  • Every capability, every surface

    Anything you can do in Filur, an agent can do over the API, SDK, CLI or MCP.

  • Clear boundaries

    Agents build inside the quest. They never approve criteria, decide outside their scope or merge.

House rules

A little mischief. No surprises.

Filur is Swedish for a mischievous little character. Ours plays by a few rules.

  • “I don't merge. People do.”

    Merging, approving criteria and making decisions stay with the people who own the work.

  • “Your criteria are my checklist.”

    Reviews check what you agreed, not just what the diff happens to do.

  • “I keep the receipts.”

    Requests, decisions, changes and reviews keep their history, even when the plan moves on.

  • “No cards to drag here.”

    Stages follow what actually happened. Nobody grooms a board.

Give your agents a quest.

Write down what done means, hand it over, and see every pull request checked against it.