Skip to content

ENPL

Apply to testApply

Rojven

A company run by AI agents. The decisions stay with a human.

Rojven is a project where every area of work – product, marketing, legal, finance, support – is done by AI agents, while a human sets the goal, the budget and the limits. The agents run on a harness: a set of roles, procedures and mechanisms that decide what can be done without a human. This page shows how it works today, where it came from and where it is heading.

Apply to testSee the harness

As of 20 November 2026. The harness runs only on Claude Code.

What Rojven is

Rojven: a fleet of AI agents – and an organisation that runs on it.

The organisation.

Rojven is run by an organisation of AI agents under human oversight – every day since 9 November 2026, in a single repository. Every action outside the repository has a pre-set approval level; spending, price changes, contracts and payments need a human decision.

The harness.

The backbone of that organisation – roles, rules, permissions, plan, metrics, a watchdog and tests – written down as files and code.

For founders.

A fleet of AI agents for your project – in your repository, on your own account with the model provider. Closed tests.

For companies.

The same harness inside an existing business. Pilot in preparation.

The name: a swarm ("rój" in Polish) plus venture – a swarm of agents with a lead that runs the venture.

The idea

The limits live in code, not in prompts.

A company where the work is done by AI agents needs what any company needs: roles, rules, a plan and oversight. Agents can be talked into things – an email can change what an agent intends to do, but it cannot change a threshold written in a file, or the verdict of a script that checks every command before it runs. That is why in Rojven the limits, the memory and the oversight are mechanisms – files, scripts and tests – rather than requests in the instructions.

Three principles:

  1. People decide, agents execute.

    A closed list of actions belongs to a human – signing, paying, logging in, approving spend.

  2. Facts, not claims.

    An agent session reporting "success" means nothing until there is evidence in the repository: a run record, a commit, a verdict.

  3. Less manual work, not less accountability.

    People decide and are accountable; agents prepare and execute within limits.

Origins

The Rojven harness grew out of experience, not theory.

The Rojven harness is built on Sebastian Jabłoński's experience of running organisations of people and of working with AI on a range of projects – among them Gilbertus, Lokavi and Rojven itself. Those projects showed that you can stand up an organisation of agents quickly – and where it hurts: the fleet stops when the computer goes to sleep; a task marked "done" is not the same as work done; security that lives only in a prompt is not security.

The harness came out of those lessons: every problem that kept coming back in practice got a mechanism – a script, a check or a test. Add to that a review of how agentic organisations are run and a dress rehearsal on a fictional company. The first release of the harness came out on 9 November 2026. Since then it has been continuously improved through the exchange of information with the fleets of Sebastian Jabłoński's projects. That is how it works: every lesson from the fleets' work goes back into the harness as a fix, so the harness keeps developing and gets a little better day by day. The more projects join, the faster it will develop – and the better and more complete it will become.

Rojven in numbers

This page describes an organisation that is working right now.

  • 1,751

    commits in the organisation's repository since 9 Nov 2026

  • 184

    owner decisions, each recorded with an ID

  • 389

    work orders between agents marked "done"

  • 51

    test groups in the organisation, no network and no model needed

These numbers measure the amount of work, not its quality. We don't compare the pace with a human team – we have no such measurement.

As of 20 Nov 2026, 23:05 CET.

The harness at a glance

The Rojven harness, latest version: v1.0-rc8.

The harness is a ready-made organisation of AI agents written into a repository: roles, work orders, a decision log, a plan, metrics and the mechanisms that limit what agents can do. It runs only on Claude Code and does not work without it; the account with the model provider, and the bill, belong to whoever runs the fleet. Rojven runs on the full version of the harness; the editions for testers and for companies are made from it.

As of v1.0-rc8, tagged 20 Nov 2026

  • 24

    agent roles

  • 26

    scheduled fleet tasks

  • 13

    processes

  • 10

    skills – procedures you start with a single command

  • 54

    scripts and modules with no language model – they count, track cost, watch and block

  • 32

    actions in the permissions matrix

  • 90

    management checks for the CEO agent

  • 48

    test groups – on a clean copy of v1.0-rc8: 48 passed, 0 failed

Three layers

People set the frame, agents do the work, code guards the limits.

  1. People.

    The owner sets the mandate, the budget and the limits; the operator does what an agent can't or shouldn't – signing, logging in, payments, identity checks. The owner can also be the operator.

  2. Agents.

    The CEO agent runs the organisation and owns the plan; role agents work in their own areas; an independent reviewer assesses every change.

  3. Mechanisms.

    Code with no language model: the permissions hook, the watchdog, the merge queue, metrics and cost tracking, tests. Memory and communication live in a git repository.

Roles and models

24 roles, like in a company – except each one has its job description in a file.

Management
CEO, PM, reviewer – plan, priorities, metrics, backlog and an independent verdict on every change.
Product
architect, engineer, tester, UX designer, analyst, operations, apps, localisation.
Growth
marketing, sales, customer support, front desk, market research.
Risk
legal, compliance, data protection, security.
Finance
finance, accounting, tax, investor relations.

Each fleet task has a model class: judge (the reviewer – a different model family from the authors of the changes), strong (decisions, code, legal, finance), light (support, front desk), mechanical (usage regulator, merging). Model IDs live in one file – a new model is one line, after evals.

How an agent works

Every agent starts with no memory – and finishes with evidence.

The organisation's memory is the repository: work orders with a deadline and a "done when" condition, decisions – one decision, one file – and each agent's log and playbook. Every run follows the same procedure: claim a time slot (so the same work never runs twice), read permissions, decisions and orders, work only within your own remit, record the result. A run ends with one line in the contract format – outcome, evidence, number of tool calls, escalation. No line means a failed run, whatever the session claims. A mistake that repeats is written down as a rule in the agent's playbook.

Plan, metrics and profitability

A plan from the year down to the day – and every metric is computed by a script.

The CEO agent's mandate is profitable growth: break-even as fast as possible, then the highest EBITDA. The plan cascades – year, quarter, month, week, day – down to a work order with a deadline. Bets (growth ideas) have an owner, a measure and a ranking by how much they bring break-even closer.

  • 109

    metrics in the sources file

  • 36

    company metrics

  • 73

    role metrics

A script computes them, no language model: green, amber, red – and red means a work order the same day.

Permissions and the hook

What an agent may do outside the repository is settled by a file and a script.

32

actions in the matrix

  • 4 an agent does on its own
  • 12 the CEO agent approves
  • 10 need an owner decision with an ID
  • 5 are done by the operator – a human
  • 1 never happens (entering card details or a password)

Anything not on the list sits at owner level.

The permissions hook checks every tool call before it runs and denies by default: a command, tool or server that isn't on the allow-list is refused; if the hook itself fails, everything is blocked. Every decision it makes goes into an audit log. Owner approval is a decision file with an ID, not a line in a chat. The hook is a guard rail, not a sandbox: it constrains the agent, but it doesn't replace sensible permissions on the machine or human review.

Gates, the rule of two, the kill switch

Money and merges pass only on a condition you can check in the data – not on trust in the agent.

Amount gate.

The amount in the command is compared with the threshold in a policy file; no amount or no threshold – refused.

Rule of two:

an agent that reads untrusted content never gets, in the same session, both access to sensitive data and the ability to change the world – at most two of those three at once.

Kill switch.

A HALT file stops every session covered by the hook at the first tool other than a read; only a human removes it, after a review.

Evals.

6 attack scenarios – including an instruction hidden in an email – check that an agent sticks to the rules before an instruction change goes live.

Prices, discounts, refunds and limits are kept in policy files; an agent doesn't negotiate them and quotes no amounts outside them.

The watchdog

A watchdog with no language model – what it reads doesn't steer what it does.

Every hour a script in GitHub Actions checks the state at the source – run tags, pull requests, work orders, contract lines, costs – not the agents' reports. It sees only IDs, numbers and dates. Its core has 7 checks: runs, pull requests without a verdict, overdue work orders, schedule consistency, budgets, agents with a streak of failures, and fleet throughput. A mismatch becomes an "Urgent" entry for whoever owns it plus an alert; when the organisation's budget runs out, the watchdog can stop the fleet with the kill switch.

  • 7

    checks in its core

The reviewer and the merge queue

Whoever wrote it doesn't approve it. Nobody merges by eye.

Every code change gets a verdict from an independent reviewer for a specific commit – against a rubric, on a different model family from the author. The queue script counts the facts (verdict, tests, conflicts, migrations) and assigns one of 29 classes; the merging agent runs only the command from the table, and the hook lets through nothing but a merge of the reviewed commit. Whenever in doubt, the queue doesn't merge – it reports.

  • 289

    tests for the queue script alone

Management oversight

90 questions, asked before the owner has to.

The CEO agent has a bank of 90 control questions, grouped from deadlines and workflow to fleet health, customers and money. Each question has a source of truth, a pass condition and an action on failure. The CEO checks 18 of them on every run; 15 are computed by a script. A failed check means a work order, a decision or an item in a human's queue – in the same turn, not a note. The checks are measured too – do they work, or do they just exist? – in weekly, monthly and quarterly cycles, with a reviewer's audit reported straight to the owner.

  • 90

    control questions

  • 18

    checked by the CEO on every run

  • 15

    computed by a script

Tests

One command for the human, the agent and CI.

  • 48

    harness test groups – no network, no language model, no secrets

  • 48 passed, 0 failed

    on a clean copy of v1.0-rc8

The tests cover permissions and data, the fleet and its runs, checks and the merge queue, numbers and finance, and starting a new organisation, releases and the exchange. CI runs the same groups on every change. A new mechanism doesn't go in without a test.

The improvement exchange and releases

The harness learns from the fleets that send in improvements.

Projects running on the harness report findings to its publisher – fixes to mechanisms that proved themselves in practice. A report is a short record about a mechanism, by design without the company's content; the publisher assesses it, writes it into the harness with tests and evals, and releases it. The data filter stops recognisable formats but won't catch everything – so whoever sends a record is primarily responsible for its content; the rules are in the Test rules and the pilot agreement. Releases ship when there are fixes; an update reaches a project as a change for review that goes through the tests, and the project's local files stay as they are.

Today the harness improves through the exchange of information with the fleets of Sebastian Jabłoński's projects, Rojven among them. The more projects join, the faster it develops and the more complete it becomes.

  • 198

    changes to the harness from 11 Nov 2026 up to v1.0-rc8

  • 22

    in the v1.0-rc8 release alone

What the harness deliberately doesn't do

A human stays wherever the law or safety requires one.

  • It doesn't pay – a human makes the transfer; an agent never enters card details or passwords.
  • It doesn't sign or open accounts – signatures, logins and identity checks belong to a human.
  • It doesn't deploy to production without a human at the start, and it doesn't automate database migrations.
  • It doesn't file tax returns – an agent prepares them, an authorised person files them.
  • Agents' output can be wrong – it has to be checked.

Coming next

Coming next – directions reported by the projects that run on the harness.

Projects running on the harness have already reported these to its publisher; they are not in the v1.0-rc8 release yet. "Accepted" means the publisher agreed with the direction – not that there is a date. We give no dates.

Merged, waiting for the next release (3)

  • A separate switch for code-change proposals sent to the publisher – independent of the exchange of short records.
  • Several fleets on one machine – each organisation with its own service and its own directory.
  • Overdue urgent work triggers a run of the role responsible for it.

Being prepared by the publisher (7)

  • A separate delivery repository for each company – the company gets only releases and a private reporting channel, with no view of anyone else's reports.
  • Honest documentation – a test that checks the version and the numbers in the harness docs against the code.
  • An easier start – an environment check before an organisation is set up, and a refusal to start with values left over from the template.
  • One release rhythm – a single source of rules for the stable and beta channels.
  • The day's plan and targets in one machine-readable file that roles and the watchdog read from.
  • Better use of the account's usage limit – starts spread out over time instead of in waves.
  • A more precise watchdog and merge queue – fewer false alarms, a fresh CI result before merging.

Reported, waiting for the publisher's assessment (4)

  • A start-up variant for an existing company – for an organisation that already has people, customers and systems, with a cautious permissions profile for the pilot.
  • Measuring the effect of a pilot – the time from work order to a result a human accepts, and the human's working time, counted mechanically.
  • A fixed set of test questions to check the quality of agents' answers before and after a change, with a cost cap.
  • A designer in the review of interface changes.

Who it's for

Two tracks: founders and companies.

Founders – closed tests.

For people who already build with AI. The fleet works in your repository and on your own account with the model provider; you get the test edition of the harness, made from the same full version Rojven runs on. During the tests you pay Rojven nothing; you pay the model provider yourself, from your own account. Improvements from testers that we rewrite into the template go into releases for testers, into the paid Rojven version, into the full version of the fleet template, which we will also make available outside the test programme under separate agreements, including free of charge, and to the member of our management board from whom we hold the rights to the template and to the licensees of that person (point 8 of the Test rules). This describes the draft Test rules – only the version you accept when you take up an invitation is binding.

You take part only once invited and after accepting the Test rules.

Apply to test

Companies – pilot.

No one has yet run the harness inside an existing company – that's why there is a pilot. Pilot in preparation. There is no fee to Rojven for the pilot; your own costs – the model provider plan, GitHub, a machine, your people's time – are yours. The fleet runs on your side, in your repository and on your account with the model provider. During the pilot, the fleet by default sends Rojven short records about improvements to mechanisms – by design without your company's content; you can pause this at any time. The terms are in the pilot agreement, which you get to read before signing. Write to us: hello@rojven.ai.

What we don't promise

What we don't promise.

  • A place in the tests – an application is an expression of interest.
  • Dates – not for the start, not for releases, not for anything under "Coming next".
  • Results, savings or a bug-free version – the harness is at the release-candidate stage for 1.0.
  • A price for the paid version – you'll see the terms before you pay anything.

Apply

Apply to become a tester.

We want to know who'd like to work with Rojven. This is an expression of interest – not admission to the programme and not a contract. You can take part in the tests only once invited and after accepting the Test rules. We'll get back to you when we send invitations.

The tests are for people aged 18 or over.

We don't collect first or last names; the form has no consent checkbox and no terms acceptance.