ruv.sgit.airUv + sgit

ruv.sgit · for clients

Agent work you can check, delivered by people

A Ruflo hive does a real piece of your work: a queen and workers, each under a written mandate for its role, with an encrypted sgit vault per job that you keep. A provider scopes it with you, starts the run, watches it and hands it over. Start with a conversation; every step after that is small enough to say yes to.

Built on rUv's open-source projects (Ruflo, RuVector, RVM, MetaHarness): MIT, by rUv / ruvnet. We build on them; we do not sell or own them. Ours: sgit vaults and Agent Behaviour Policies, Apache-2.0. Materials: CC BY 4.0.

The engagement path

Five steps. Each ends with something you keep, and you can stop after any of them. Prices are the published list prices in GBP, excluding VAT, the same for every provider.

  1. A conversation

    What you want agents to do, and what they must never do.

    Free

    You keep: notes, and a proposed first run.

  2. A first run

    A task run on a real problem: a Ruflo queen and up to 5, 10 or 20 workers, no network access, materials provided up front.

    £10, £20 or £50 a run

    You keep: the run's vault.

  3. Expert time

    About two hours to steer it, or a day to write the behaviour policy for one team.

    £500 or £1,500

    You keep: the policy and the vault.

  4. A pilot

    Four working days setting it up in your own environment, with your policies and your first runs.

    £5,000

    You keep: the setup, its policies and vaults.

  5. Run it yourself

    The maintained repository: the code that runs this, in a private repository of your own, kept current.

    from £149 a month

    You keep: the repository.

Dedicated compute can be added to any step; it is designed, not built yet, and the reply to an order says so. The full path, with matching and delivery, is in How it works.

The four offers

Mix and match. Put what fits in the cart and send it: there is no payment step, the order comes to agent@riskmandate.ai by email, and a person replies with dates and a quote. Or enquire first.

Reading data/offers.json…

Five project types

Most engagements start as one of these. The offers named under each are a suggested starting combination, not a fixed package: you and the provider agree the actual combination in the first conversation, and the reply sets out the quote.

Reading data/project-types.json…

The providers

The marketplace starts with two founding providers. Both offer the same four offers at the published list prices. Name one when you enquire or order, or leave it open: for now, enquiries are matched by hand, by project type, language, location and availability, and you choose.

Reading data/providers.json…

Deliver this yourself? See For providers and apply to join.

What stays yours

Everything we publish is open, so anybody can do this without us. Your part of an engagement is not.

Your code and data

They stay yours, under your own terms. We do not publish them, reuse them or keep them beyond the engagement.

The vault

Each job runs in its own encrypted sgit vault: a branch per worker, every delivery committed. At the end it is handed to you, as a zip or with a read key only you choose to publish, and deleted from our side, with the delete checked.

Private first

Everything to do with a client is private by default. A ledger entry or a case study is published later, and only with your agreement; then only the measurements.

What goes back

Improvements to the shared code, playbooks and behaviour-policy patterns go back to the public repositories, with your name and data removed. Code created in an engagement is Apache-2.0 unless agreed otherwise in writing.

The full terms, with worked examples of who bills and how revenue is split, are in the rules of engagement.

Who does what

WhoDoes
You, the clientSay what you want done and what must never happen; provide the materials; own your code, your data and the vault.
The provider who has you as a clientScopes the job, writes the brief with you, bills you, and is your single contact.
The provider(s) who deliverWrite the behaviour policy per role, start the run, watch it to the end, review the output and hand it over.
The agentsA Ruflo queen and workers, each under its role's mandate, delivering into the run's vault.
The marketplace (for now, the two founding providers)Matches enquiries to providers, keeps the rules and the playbooks.

Each job is a ruv.sgit run: a run spec, a mandate per role (no network by default), a vault per run, a person watching, a measured close, and a ledger entry. The steps are in How it works.

For consultancies and product companies

Add agent work to what you already sell

Your clients are asking what you do with agents, and you cannot hand their data to something you cannot show. Answer with something you can show: a hive with a written mandate per role, an encrypted vault per run, and a ledger with the numbers.

Who this is for

  • Consultancies that want a delivery practice built on agent hives, with evidence a client's risk team will accept.
  • Product companies that want agent runs inside their product, under their brand.

What stays with you

  • Your clients. The relationship is yours; whoever has the client bills.
  • Your brand. White label or your own deployment: the offering and the delivered vaults carry your name.
  • Your keys. Vault keys stay in your secret store, never printed, logged or committed. The vault server holds ciphertext only.

Start cheap, move along as demand is proven

  • Resell runsBuy task runs and sell them on, with your expertise around them. Nothing to deploy.
  • White labelYour brand on the offering and the deliverables, with a provider running the hives behind you; you hand your clients their run vaults.
  • Your own deploymentThe maintained repository (the white-label tier is ready to offer under your name), on Claude Code, on AWS or anywhere you choose. Dedicated compute is designed, not built yet.

Each step uses the same runner, behaviour policies and vaults. Custom arrangements, especially for companies that bring the work or an existing project, are possible and agreed in writing before work starts. rUv's projects stay attributed as their licences require (MIT, by rUv / ruvnet).

For platform, AI enablement, security and risk teams

Agents inside your organisation, with the governance written down

People across the organisation want agents doing real work. Security, risk and legal want to know what those agents can touch, before they say yes. This gives both.

A written mandate per role

An Agent Behaviour Policy for each role: what it can reach, what it is mandated to do, the barrier between the two, and the person who owns it.

Enforced, not advised

The mandate compiles into Ruflo's own policy engine in enforce mode (on a fresh project it runs in legacy mode; observe sits between). Ruflo writes a hash-chained receipt for every decision. Reading data/report.json… POC1

No network by default

Runs get no internet. Materials are provided up front, and the policy denies egress.

Data with a short life

Files are encrypted on the client before upload; the server stores ciphertext under opaque ids. One vault per run holds everything it made; at the close it is measured, handed over and deleted, and the delete is checked.

Where it runs

  • In your own environment: the maintained repository, kept current and set up for your stack, on Claude Code, on AWS or anywhere you run code.
  • On its own machine: dedicated compute, one AWS EC2 instance per task, with the vault created inside it. Designed, not built yet.

How a provider helps you start

  • A couple of hours to review your first policy.
  • A day to run the first hive with your team.
  • Four days to set up your deployment and hand it over.

The proof

Most of this site and the talk were made by ruv.sgit runs, and every run is in a public ledger. These numbers are read from data/vaults.json as the page loads.

…runs in the ledger
…vault commits
…probed text fragments found in what the vault server stored
…fresh clones identical, file by file

The business plan sets out the offers, the prices and the arithmetic behind them. Where it differs from the rules of engagement (the revenue split), the rules apply.

What this does not claim. Runs are not automated end to end: a person starts each one, watches it and hands it over, and the prices cover that time. The runs on this site used a local vault server on the machine that ran the hive, so their timings are local numbers; they were not policy-gated (enforcement was shown separately, in POC1). Dedicated compute and the materials sandbox for uploads are not built yet. The site takes no payment, and there is no paid engagement yet: the prices are the business plan's starting list prices. This is not rUv's offer and does not speak for him or for the Agentics Foundation.

Talk to us

agent@riskmandate.ai

A live agent answers; a person follows up. Every enquiry and every order from the shop goes to this address.