ruv.sgit providers · how it works
How it works
From a first conversation to a pilot and a setup you run yourself: who does what, how a provider is matched, the provider workflow from enquiry to handover, how each job is delivered as a ruv.sgit run, and how what we learn goes back to the public repositories.
From article No. 9, From the talk to the service, with the decisions of 21 October applied (enquire to book). The money and ownership rules are on Rules of engagement. Built on rUv's open-source projects (Ruflo, RuVector, RVM, MetaHarness): MIT, by rUv / ruvnet.
The engagement path
Five steps, each worth having on its own. Prices are the published list prices for every provider, in GBP excluding VAT, read from data/offers.json.
| Step | What happens | Price today | What the client keeps |
|---|---|---|---|
| 1. A conversation | What the client wants agents to do, and what they must never do | free | 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 (£9, £17 or £40 with your own model key) | the run's vault |
| 3. Expert time | Two hours to steer it, or a day to write the behaviour policy for one team | £500 (about two hours) or £1,500 (a day) | the policy and the vault |
| 4. A pilot | Four days setting it up in the client's own environment | £5,000 | the setup, its policies and vaults |
| 5. Run it yourself | The maintained repository: the code that runs this, kept current | from £149 a month (£149, £499, £1,500) | the repository |
Dedicated compute (£21, £23 or £36 per eight-hour block) can be added to any step; it is designed, not built yet, and the reply to an order says so. The five project types (a first run with a guide; a behaviour policy for one team's agents; a four-day pilot; a talk or workshop built the way ours was; a review of an agent that is already running) are packages of these offers, listed on For clients.
Enquire to book: the button opens an email to agent@riskmandate.ai; a person replies with dates and a quote. The site takes no payment.
Who does what
| Who | Does |
|---|---|
| The client | Says what they want done and what must never happen; provides the materials; owns their code, data and the vault |
| The provider who has the client | Scopes the job, writes the brief with the client, bills, and is the client's single contact |
| The provider(s) who deliver | Write the behaviour policy per role, start the run, watch it, review the output and hand it over |
| The agents | A Ruflo queen and workers, each under its role's mandate, delivering into the run's vault |
| The marketplace (for now, the two founders) | Matches enquiries to providers, keeps the rules and the playbooks, reviews applications |
How a provider is matched
For now, by hand. An order or an enquiry arrives at agent@riskmandate.ai (a live agent answers; a person follows up). If it names a preferred provider, it goes to them. If not, the founders match it by project type, language, location and availability, and reply with one or two names. The client chooses. Nothing is automated.
A client can name a provider from the start: each provider's page has its own enquire to book button, and the shop has a preferred-provider field (with Dinis Cruz, with Mondweep Chakravorty). See the providers.
The provider workflow, from enquiry to handover
What a founding provider does with an engagement, step by step: who does it, what it produces, and where that lives. Client material lives in email and in the engagement's private vault, and never in this site's git repository. The only step that touches a public repository is step 8, and it carries no client name or data.
An enquiry arrives
The client writes to agent@riskmandate.ai, from an enquire to book button on this site or from the shop, naming a preferred provider or none. The enquiry says who it is for, the offer, what agents should do, what they must never do, and when to start. A live agent answers; a person follows up.
- Who
- The client; the agent at agent@riskmandate.ai acknowledges
- Produces
- The enquiry email (or the shop's emailed order)
- Lives in
- email the mailbox at agent@riskmandate.ai; never this git repository
Triage and match
By hand, by the two founders. A named provider gets the enquiry. Otherwise the founders match by project type, language, location and availability, and reply with one or two names; the client chooses. The time to reply is agreed with the client. From here the provider who has the client is the client's single contact.
- Who
- The two founders
- Produces
- A reply to the client naming the provider (or two to choose from)
- Lives in
The first conversation (free)
The provider who has the client talks it through: the objective, what must never happen, the materials, and how sensitive the data is. It ends with a proposed first run.
- Who
- The provider who has the client, with the client (and the delivering provider, if another)
- Produces
- Notes, and a proposed first run, sent to the client
- Lives in
- email between the client and the provider; the materials themselves are part of the run spec (step 5)
The quote, and the written note between providers
Whoever has the client bills, quotes and signs with the client: list prices, GBP excluding VAT, direct costs itemised. When more than one provider is involved, they agree a short written note (an email is enough to start): who bills, who delivers, who the parties are, and that revenue is split equally after direct costs.
- Who
- The provider who has the client; every provider in the engagement for the note
- Produces
- The quote; the note between providers; the contract, signed by whoever bills
- Lives in
- email between the parties
The run spec, and a mandate per role
The delivering provider writes the run spec (the client's objective, the materials, one task per worker) and an Agent Behaviour Policy for each role: what it can reach, what it may do, and what is stopped. No network by default.
- Who
- The provider(s) who deliver; the client agrees the objective and the limits
- Produces
- The run spec and one mandate (ABP) per role
- Lives in
- private vault the engagement's vault; never this git repository (the public run specs here are for our own runs)
The run: open, deliver, close
The vault is created when the run opens, with a branch per worker; every delivery is committed and merged, and the server stores ciphertext only. A provider starts the run and watches it to the end. At the close the vault is measured (commits, files, bytes, a plaintext probe of the server's store, a fresh clone compared file by file), then handed to the client, as a zip or with the read key, and deleted from our side, with the delete checked. How it is handed over is set before the run starts, in the run spec's visibility field (article No. 10): client work is private, the default, so the read key goes to the client privately and only the client can choose to publish it. The last step is the seal: the vault key is deleted, so nobody, us included, can add to the vault.
- Who
- The provider(s) who deliver; the agents (a Ruflo queen and workers) under their mandates
- Produces
- The deliveries, the measurements, the vault for the client
- Lives in
- private vault until it is handed over and deleted from our side
Review and handover; the invoice
The delivering provider reviews what the run made and hands it over with the vault. Whoever has the client invoices: direct costs are reimbursed first to whoever paid them, itemised; what is left is split equally, and the biller pays the other parties their share. The biller charges VAT where it applies.
- Who
- The delivering provider (review and handover); the provider who has the client (the invoice and the payments)
- Produces
- The handover to the client; the invoice; the shares paid
- Lives in
- private vault with the client; the invoice by email
Commit back
Everything that is not the client's (a better playbook, a fix to the runner, a new behaviour-policy pattern, a reusable worker role) goes back to the public repositories as a pull request, with the client's name and data removed, credited to the provider who made it. Improvements to rUv's projects are offered to them under their own licence and contribution rules.
- Who
- The provider who made the change
- Produces
- Pull requests to the public repositories
- Lives in
- public repositories code and playbooks only; no client name, code or data
The ledger entry
What ran, how long, and what the checks found. Private by default for client work; published only with the client's written agreement, and then only the measurements, never the content.
- Who
- The delivering provider
- Produces
- The ledger entry for the run
- Lives in
- private by default not on the public ledger unless the client agrees in writing, and then only the measurements
Nothing here is automated: a person matches, starts, watches and hands over every run. The rules behind each step are on Rules of engagement (rules 4 to 9, and 11 to 16).
How the work is delivered
Every job is a ruv.sgit run, the same way every material on this site was made (see one run, six steps):
A run spec
The client's objective, the materials, and one task per worker.A mandate per role
An Agent Behaviour Policy for each worker: what it can reach, what it may do, and what is stopped. No network by default.A vault per run
Created when the run opens, a branch per worker, every delivery committed and merged. The server stores ciphertext only.A person watches
A provider starts the run, watches it to the end and reviews what it made.The close
The vault is measured (commits, files, bytes, a plaintext probe of the server's store, a fresh clone compared file by file), handed to the client as a zip or with a read key they choose to publish, and deleted from our side, with the delete checked.A ledger entry
What ran, how long, and what the checks found. Private by default for client work; public with the client's agreement.
How changes are committed back
During a job, two kinds of change happen. The client's own code and data go into the client's vault and stay there (rule 4). Everything else, a better playbook, a fix to the runner, a new behaviour-policy pattern, a reusable worker role, goes back to the public repositories as a pull request, with the client's name and data removed, and is credited to the provider who made it (rule 5). The changes list of each public repository then shows what the engagements taught us.
This builds on rUv's open-source projects (MIT, by rUv / ruvnet). It is not rUv's offer, and does not speak for him or for the Agentics Foundation.