ruv.sgit providers · rules of engagement
Rules of engagement
The rules every engagement through ruv.sgit providers follows: what is open, what stays the client's, how changes come back, how the money is split and who bills. For clients and for providers, in one place.
These rules are taken from article No. 9, From the talk to the service (the rules in Dinis Cruz's words and order), with his decisions of 16 and 21 October applied: the split is equal after direct costs, materials are CC BY 4.0, client work is private first, engagements are enquire to book, and the proposed answers to the article's open questions 5 to 14 are now rules (11 to 16 below). If this page and the article ever differ, the article's approved version is the source, and this page is corrected.
The rules
Everything here is open.
Everything we do is open source and Creative Commons. We publish all the materials, all the playbooks and how to do it. Our code is Apache-2.0. Our materials and playbooks are Creative Commons Attribution 4.0 (CC BY 4.0), which lets anyone reuse them, including commercially, as long as they credit the source. rUv's projects, which this builds on, are MIT, by rUv / ruvnet.
You can do this without us, and we encourage it.
Anybody can take the code, the playbooks and the method and deliver this to their own clients, under their own name, with no permission, no fee and no obligation to tell us. Anybody who implements this implements sgit vaults and Agent Behaviour Policies, and that is the outcome we want either way.
Code created in engagements through us is open.
When an engagement comes through this marketplace, the code it creates is published under Apache-2.0, so the next client and the next provider start from it.
The client's code and data are the client's.
The exception to rule 3: the client's own code and data stay proprietary to the client. We do not publish them, reuse them or keep them beyond the engagement. Each job runs in its own encrypted vault, which is handed to the client at the end and deleted from our side.
Changes are committed back.
Improvements we make to the shared code, playbooks and behaviour policies during an engagement go back to the public repositories. Improvements to rUv's projects are offered to them under their own licence and contribution rules.
Revenue is split equally between the parties, after costs.
Direct costs (model tokens, compute, other third-party costs) are first reimbursed to whoever paid them, itemised; what is left is split equally. Two parties: half each. Three parties: a third each. There is no separate platform share. A party is a provider (a person or a company) that brings the client or delivers part of the work; one provider doing both is one party; bringing a client without delivering any of the work still counts as a party.
Whoever has the client bills.
If you bring the client, you invoice them and pay the other parties their share. If we bring the client, we invoice and pay you yours.
Custom arrangements are possible.
Especially for companies that bring the work, and for bringing this into an existing project. They are agreed in writing, before the work starts.
Every job leaves evidence.
Each job is a ruv.sgit run: a vault per run, a mandate per role, and a ledger entry. The client keeps the vault. Everything to do with a client is private first: the ledger entry is private unless the client agrees in writing to publish it, and then only the measurements, never the content.
Credit where it is due.
rUv's projects are named and credited as his (MIT, by rUv / ruvnet). We build on them; we do not sell or own them. This is additive to his stack.
The details
The article's open questions 5 to 14 each had a proposed answer. On 21 October Dinis accepted them; those that are rules are stated here.
Prices are public and fixed, for now.
The published prices are the list prices for every provider. Per-provider price bands within a range come later, once there are more providers.
Open question 5Prices are in GBP, excluding VAT.
The party who bills charges VAT where it applies. Other currencies are quoted on request.
Open question 11Direct costs are reimbursed before the split, itemised on the invoice.
Third-party costs (model tokens, compute) are reimbursed to whoever paid them before the split, and itemised on the invoice.
Open question 7, and rule 6Whoever bills signs.
Whoever bills signs the contract with the client. Providers in an engagement agree the rules of engagement with each other in a short written note (an email is enough to start).
Open question 8, and rule 7New providers are vetted by the founders, until there are five.
Joining takes six steps: apply, proof of work, peer review, an interview, a shadowed first pilot, and standards. The founders do the proof-of-work review and the interview until there are at least five providers; then peer review is by two members.
Open question 10A client who wants everything closed has a custom arrangement.
When a client wants everything closed, including the code an engagement creates, that is a custom arrangement under rule 8, agreed and priced before the work starts.
Open question 14, and rule 8
The other accepted answers are not rules but settle the same picture: who counts as a party (question 6) is in rule 6; ledger entries for client work (question 9) are in rule 9; the marketplace is called "ruv.sgit providers", delivering "agentic engagements" (question 12); and it stays on ruv.sgit.ai, as release v0.2.0 (question 13).
Worked examples
The examples use the published prices in data/offers.json (GBP, excluding VAT). Direct costs paid to third parties (model tokens, compute) come off the top before the split, itemised, and go back to whoever paid them.
| Case | Who brings the client | Who delivers | Who bills | The split |
|---|---|---|---|---|
| We bring the client, two parties | We do (Dinis) | Mondweep, with Dinis | We do: £1,500 for a day of expert time | £750 each |
| A provider brings the client | A provider | The provider, with us on the behaviour policy | The provider: £5,000 for a four-day pilot | £2,500 each; the provider pays us our half |
| Three parties | A provider | That provider, a second provider, and us | The provider who brought the client: £5,000 for the pilot | A third each: £1,666.67, £1,666.67 and £1,666.66 (the odd penny stays with whoever bills) |
| A company brings an existing project | The company | The company's team, with a provider | Agreed in writing before the work starts | Custom (rule 8) |
| Somebody does it without us | Them | Them | Them | Nothing to split, nothing to ask (rule 2) |
The arithmetic is checked by site/build/rules_check.py: each split adds up to the price, less direct costs, to the penny, and each price is the list price in data/offers.json. The figures it reads are below, in the page.
Licences, in one place
| What | Licence | Whose |
|---|---|---|
| Our code (this site, the runner, the ABP tools) | Apache-2.0 | ours, open |
| Materials and playbooks (articles, briefs, how-tos) | Creative Commons Attribution 4.0 (CC BY 4.0) | ours, open |
| Code created in engagements through us | Apache-2.0 | open, unless agreed otherwise in writing (rule 8) |
| The client's code and data | the client's own terms | the client's, proprietary |
| rUv's projects (Ruflo, RuVector, AgentDB, MetaHarness, RVM) | MIT | rUv / ruvnet |
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.
Enquire to book
To start an engagement, enquire: the button opens an email to agent@riskmandate.ai, and a person replies with dates and a quote. The site takes no payment.
Enquire to book