{
 "title": "Autonomy with a mandate and a memory",
 "event": "Agentic Engineering Live: rUv in London, 15 Oct 2026",
 "speaker": "Dinis Cruz",
 "duration_s": 698,
 "source": "ruv.sgit.ai: every number on screen is read from data/report.json, data/vaults.json, studio/run.json or a recorded run under evidence/",
 "data": {
  "report": "../data/report.json",
  "vaults": "../data/vaults.json"
 },
 "beats": [
  {
   "id": "open",
   "at": 0,
   "dur": 30,
   "title": "Many hands + memory + a mandate",
   "slide": {
    "layout": "iframe",
    "src": "../ruv-sgit/define/equation/index.html",
    "fallback": "../assets/img/talk/equation.webp",
    "heading": "Autonomy with a mandate and a memory",
    "sub": "ruv.sgit: a Ruflo hive + sgit vaults + Agent Behaviour Policies · Dinis Cruz · sgit.ai · ruv.sgit.ai"
   },
   "say": "Hi, I'm Dinis. I build sgit: git for encrypted vaults. This animation was made by agents: a Ruflo hive whose Claude Code workers shared one ephemeral sgit vault. And it is tonight's equation. Many hands: a Ruflo hive. Plus a memory: sgit vaults. Plus a mandate: Agent Behaviour Policies. Equals ruv.sgit. Every number on screen comes from a recorded run, in files you can open.",
   "cue": "7:00 pm, first of three community talks; rUv's keynote was at 6:00. Livestreamed. The equation was made by ruv.sgit run r3-define."
  },
  {
   "id": "claim",
   "at": 30,
   "dur": 23,
   "title": "The claim",
   "slide": {
    "layout": "iframe",
    "src": "slides/claim/index.html",
    "fallback": "../assets/img/talk/claim.webp",
    "heading": "The claim",
    "sub": "Encrypted · versioned · scoped to one run · a written mandate: each number read from data/vaults.json and data/report.json"
   },
   "say": "rUv's stack gives agents swarms, consensus, self-learning and speed, with its own policy engine and memory. What we add is a memory with history, and a mandate. Here a worker learns something. It is encrypted before it leaves the agent, so the server only ever holds ciphertext: zero plaintext found, across every run. It is versioned, so you know who learned what, and when. It is scoped to one run: the vault is measured, then deleted. And a mandate, written down, compiled into Ruflo's own policy engine: six of eleven actions stopped. Tonight is mostly about the memory."
  },
  {
   "id": "stack",
   "at": 53,
   "dur": 8,
   "title": "rUv's stack, as an AI infographic",
   "slide": {
    "layout": "image",
    "src": "../assets/img/ruv-stack-layers.webp",
    "caption": "Bottom to top: RVM, RuVector, Ruflo, MetaHarness, the hosts · all MIT, by rUv / ruvnet",
    "heading": "rUv's stack, in one picture",
    "sub": "An infographic drawn by an image model",
    "builds": [
     {
      "at": 3.5,
      "text": "… but that was before we had <b style=\"color:var(--accent)\">ruv.sgit</b> 🙂"
     }
    ]
   },
   "say": "Here's rUv's stack as an infographic, drawn by an image model. Pretty cool. But that was before we had ruv.sgit. Here's the same picture, made that way."
  },
  {
   "id": "stack-ruv",
   "at": 61,
   "dur": 22,
   "title": "rUv's stack, one picture",
   "slide": {
    "layout": "iframe",
    "src": "slides/stack/index.html",
    "fallback": "../assets/img/talk/stack.webp",
    "heading": "rUv's stack, one picture",
    "sub": "Bottom to top: RVM, RuVector, Ruflo, MetaHarness, the hosts · all MIT, by rUv / ruvnet · and where sgit plugs in"
   },
   "say": "His stack, bottom up: RVM, the capability VM. RuVector, the memory. Ruflo, the orchestrator, with queens and workers. MetaHarness, which assembles a harness for a host. And on top, the hosts you already use. It's overwhelming because it's complete, and it's all MIT. I plug into three places: a vault around the memory, one vault per hive run, and an ABP compiled into Ruflo's policy engine."
  },
  {
   "id": "ruvector",
   "at": 83,
   "dur": 38,
   "title": "Memory: what RuVector secures, and where sgit adds",
   "slide": {
    "layout": "iframe",
    "src": "slides/ruvector/index.html",
    "fallback": "../assets/img/talk/ruvector.webp",
    "heading": "RuVector secures the memory; sgit wraps the files",
    "sub": "RuVector README, \"Security and governance\" (github.com/ruvnet/ruvector, main branch, read 15 Oct 2026) · sgit figures from data/vaults.json"
   },
   "say": "Start with the memory. RuVector is a remarkable memory substrate: vectors, graphs, full snapshots, even copy-on-write branches. And its README has a clear section on security and governance. Its witness logs are tamper evident, and it says, just as plainly, that they do not encrypt memory content, and that a delete does not automatically reach every snapshot, branch or copy, so define retention and erasure across every copy. That is where sgit adds, around the files: encrypted on the client, AES-256-GCM, so the server only ever stores ciphertext; a history you can clone anywhere; and a vault that is deleted with the run, and checked: no store paths left, and a clone with the key fails."
  },
  {
   "id": "sgit",
   "at": 121,
   "dur": 28,
   "title": "What an sgit vault is",
   "slide": {
    "layout": "iframe",
    "src": "slides/sgit/index.html",
    "fallback": "../assets/img/talk/sgit.webp",
    "heading": "What an sgit vault is",
    "sub": "git for encrypted vaults: encrypted on the client, versioned like git, ephemeral when you want · sgit-ai 0.21.0 · timings from data/vaults.json"
   },
   "say": "So what is an sgit vault? It's git for encrypted vaults. A folder on your machine; every file is encrypted on the client, AES-256-GCM, before anything leaves, so the server only ever stores ciphertext. Whoever has the vault key has the memory. And it works like git: commit, branch, merge, push, clone, each about a second against our local vault server. For agents, that's a shared, versioned memory across machines: a fresh clone anywhere gets the whole history back. Or make it ephemeral: one vault per run, deleted at the end, and we check the delete."
  },
  {
   "id": "abp",
   "at": 149,
   "dur": 28,
   "title": "What an Agent Behaviour Policy is",
   "slide": {
    "layout": "iframe",
    "src": "slides/abp/index.html",
    "fallback": "../assets/img/talk/abp.webp",
    "heading": "What an Agent Behaviour Policy is",
    "sub": "A written mandate per role, compiled into Ruflo's own policy engine, with receipts"
   },
   "say": "This is an Agent Behaviour Policy: a written mandate, per role, that a person can read. One row per capability, in a small grammar of 23 primitives: verb, object, reach. Each row says yes, no or ask a human, why, and the barrier. It has an owner and an end date. We don't build a new enforcer: it compiles into Ruflo's own policy engine, rUv's, in enforce mode: 36 rules. Then real actions hit it. In POC1, 6 of 11 were stopped: 4 denied, 2 sent to a human. Every decision went into a hash-chained receipt, and the chain is valid."
  },
  {
   "id": "ruv-sgit",
   "at": 177,
   "dur": 45,
   "title": "ruv.sgit: one hive, one vault, one run",
   "slide": {
    "layout": "iframe",
    "src": "../ruv-sgit/define/layers/index.html",
    "fallback": "img/ruv-sgit-layers.webp",
    "sub": "ruv.sgit: a Ruflo hive + sgit vaults + Agent Behaviour Policies",
    "caption": "The layers · made by ruv.sgit run r3-define · policy outcomes from POC1, vault from run r2-materials"
   },
   "say": "So put the two together. ruv.sgit is a Ruflo hive plus sgit vaults plus Agent Behaviour Policies: a queen and workers in parallel, one ephemeral vault per run, and a written mandate for what each worker may do. Each worker's delivery lands on its own branch; the branches merge; the run is measured into a ledger; and then the vault is deleted. Memory that exists for exactly as long as the work does, with a receipt afterwards. Tonight's three new pages, and this script, were made by one such run: run r2-materials, five workers, on a local vault server.",
   "cue": "The animation runs itself: hive on top, the mandate in the middle (POC1 outcomes), the vault below (r2-materials), then the stack lays flat into the tagline."
  },
  {
   "id": "lanes",
   "at": 222,
   "dur": 25,
   "title": "Vault lanes",
   "slide": {
    "layout": "iframe",
    "src": "../studio/v3/index.html",
    "fallback": "../studio/posters/v3.webp",
    "caption": "Studio v3 · vault lanes: one lane per agent role, commits, merges, a fresh clone · an illustration built in studio run 1",
    "speed": 1.4
   },
   "say": "Here's the shape of it, as an illustration. One lane per agent role: that lane is a branch of the vault. Each dot is a commit, encrypted before it is uploaded. The lanes merge into the main line, which sgit calls current. And at the end, a fresh clone, into an empty folder, pulls the whole history back. The server held ciphertext throughout. Whoever has the key has the memory, and nobody else does, including the host.",
   "cue": "Let the animation run; speak over it, then pause for the fresh clone."
  },
  {
   "id": "history",
   "at": 247,
   "dur": 36,
   "title": "Memory with history",
   "slide": {
    "layout": "iframe",
    "src": "slides/history/index.html",
    "fallback": "../assets/img/talk/history.webp",
    "heading": "One run's vault, commit by commit",
    "sub": "ruv.sgit run r5-market, 15 Oct 2026 · POC2, 14 Oct 2026 · sgit times as measured"
   },
   "say": "This is a real run's vault, from this afternoon. The brief lands on current. Then each worker gets its own branch, commits what it delivered, and merges back: who, what, when, and how long each sgit step took, in milliseconds. Now the flow: six workers, eight commits, encrypted on the client before the push. The server holds ciphertext only: we searched it for forty fragments of the text and found none. A fresh clone came back identical, and then the vault was deleted, with nothing left. Memory works the same way. In POC2, run locally, a coder and a tester each wrote their Ruflo memory to the vault; the folder was deleted, a fresh clone restored it, and Ruflo gave the same answers. Every step is a commit, and it's gone when the run is."
  },
  {
   "id": "studio-v1",
   "at": 283,
   "dur": 20,
   "title": "Studio v1: the diagram that builds",
   "slide": {
    "layout": "iframe",
    "src": "../studio/v1/index.html",
    "fallback": "../studio/posters/v1.webp",
    "heading": "Studio v1: the diagram that builds",
    "sub": "SVG only: agents, the ABP gate, the vault, receipts, built step by step · made in studio run 1 (a Ruflo hive of Claude Code subagents)",
    "speed": 1.47
   },
   "say": "Seven animations of this story were built in parallel by a Ruflo hive of Claude Code workers. Version one: a diagram that builds, the agents, the mandate's gate, the vault, the receipts."
  },
  {
   "id": "studio-v2",
   "at": 303,
   "dur": 20,
   "title": "Studio v2: messages in flight",
   "slide": {
    "layout": "iframe",
    "src": "../studio/v2/index.html",
    "fallback": "../studio/posters/v2.webp",
    "heading": "Studio v2: messages in flight",
    "sub": "the queen hands tasks to workers; envelopes travel through the vault between them · made in studio run 1 (a Ruflo hive of Claude Code subagents)",
    "speed": 1.47
   },
   "say": "Version two: messages in flight. The queen hands tasks to workers, and every envelope passes through the vault, encrypted."
  },
  {
   "id": "studio-v4",
   "at": 323,
   "dur": 20,
   "title": "Studio v4: the policy gate",
   "slide": {
    "layout": "iframe",
    "src": "../studio/v4/index.html",
    "fallback": "../studio/posters/v4.webp",
    "heading": "Studio v4: the policy gate",
    "sub": "11 actions fly at a gate twice: the default lets all through; the ABP denies 4, holds 2 for a human, lets 5 through · made in studio run 1 (a Ruflo hive of Claude Code subagents)",
    "speed": 1.79
   },
   "say": "Version four: the policy gate. The same eleven actions, twice. Ruflo's default lets all of them through; the ABP denies four, holds two for a human, and lets five through, with receipts."
  },
  {
   "id": "studio-v5",
   "at": 343,
   "dur": 20,
   "title": "Studio v5: the isometric office",
   "slide": {
    "layout": "iframe",
    "src": "../studio/v5/index.html",
    "fallback": "../studio/posters/v5.webp",
    "heading": "Studio v5: the isometric office",
    "sub": "one desk per role, a vault safe in the middle, envelopes walking between desks and the safe · made in studio run 1 (a Ruflo hive of Claude Code subagents)",
    "speed": 1.74
   },
   "say": "Version five: an isometric office. A desk per role, the vault as a safe in the middle, and envelopes walking between them."
  },
  {
   "id": "hive",
   "at": 363,
   "dur": 25,
   "title": "The hive in 3D",
   "slide": {
    "layout": "iframe",
    "src": "../studio/v6/index.html",
    "fallback": "../studio/posters/v6.webp",
    "caption": "Studio v6 · the hive in 3D · studio run 1: ruflo hive-mind 3.56.10, 8 specialists, 7 tasks, 31 calls, none failed · evidence/poc7-trace.jsonl",
    "speed": 1.3
   },
   "say": "What does a vault add to a hive? In our first studio run, Ruflo's hive-mind coordinated eight specialists: thirty-one calls, none failed. In that run, its shared memory returned OK on set and key not found on the next get, so results went along as broadcasts. ruv.sgit adds a vault alongside: one shared, versioned memory per run."
  },
  {
   "id": "motion",
   "at": 388,
   "dur": 40,
   "title": "ruv.sgit in motion",
   "slide": {
    "layout": "iframe",
    "src": "../ruv-sgit/motion/index.html",
    "fallback": "img/ruv-sgit-motion.webp",
    "caption": "ruv.sgit in motion · a real run, drawn from its entry in data/vaults.json",
    "speed": 1.2
   },
   "say": "This is ruv.sgit in motion, drawn from a real run's entry in the ledger, not a mock-up. The run opens: the hive starts, the vault is created, and the brief is committed. The workers start in parallel. Each delivery lands on its own branch, is pushed, and merges into current. Every sgit call and every Ruflo call is timed and recorded as it happens. Then the close: the vault is measured, cloned fresh, and checked against what the workers delivered. Then it's gone. Watch the branches: the workers work in parallel, nobody writes on anyone else's branch, and the deliveries merge one at a time. The merge is where the work meets, and the history keeps who did what.",
   "cue": "Check which run the page shows before naming it."
  },
  {
   "id": "ledger",
   "at": 428,
   "dur": 34,
   "title": "How to read the ledger",
   "slide": {
    "layout": "iframe",
    "src": "slides/ledger/index.html",
    "fallback": "../assets/img/talk/ledger.webp",
    "heading": "The vault ledger: one row per run",
    "sub": "Every number read at load from data/vaults.json, written after each run by poc/ruv-sgit/ruvsgit.py"
   },
   "say": "Every run leaves one row in a ledger. Here's how to read one. The run, and what it was for. The workers, each writing on its own branch. The commits. What they delivered, and what the server held: all ciphertext. Then the probe: fragments of the delivered files, searched for in every byte the server stored. Plaintext found: zero. A fresh clone with the key: identical. Then the vault is deleted, and we check: nothing left in the store, and a clone fails. Now every run, and the totals. Ephemeral: every vault deleted after its numbers were recorded.",
   "cue": "Point at the plaintext-found cell, then the ephemeral line."
  },
  {
   "id": "city",
   "at": 462,
   "dur": 20,
   "title": "The city of vaults",
   "slide": {
    "layout": "iframe",
    "src": "../studio/v7/index.html",
    "fallback": "../studio/posters/v7.webp",
    "caption": "Studio v7 · the city of vaults: a street per branch, a floor per commit, the Agent Behaviour Policy (ABP) as the city wall · built by a Claude Code subagent"
   },
   "say": "Zoom out, and it's a city: each branch a street, each commit a floor, the mandate as the wall, with its gates. Seven of these animations were built in parallel by Claude Code subagents, coordinated by a Ruflo hive on its own, in one studio run: about six hundred and thirty thousand tokens, and under ten minutes each. Three of them are in this talk; all seven are on the site. Which brings us to the wall."
  },
  {
   "id": "table",
   "at": 482,
   "dur": 30,
   "title": "Same 11 actions, default against the ABP",
   "slide": {
    "layout": "table",
    "caption": "POC1 · the same trace evaluated twice, recorded 14 Oct 2026 · data/report.json",
    "columns": [
     "role",
     "action",
     "resource",
     "Ruflo default",
     "with the ABP"
    ],
    "rows_from": "report",
    "reveal_from": 3,
    "reveal_every": 3
   },
   "say": "So we write it down: an Agent Behaviour Policy, one row per capability, compiled into Ruflo's own engine. The same eleven actions, played twice. On the left, the default: all allowed. On the right, the mandate: email denied, pastebin denied, the tester editing source denied, the researcher reading AWS credentials denied; and the push and the deploy wait for a human. Six of eleven stopped, five allowed, every reason names its row, and every decision is a hash-chained receipt.",
   "cue": "Rows reveal every 3 s; the stopped ones are the point."
  },
  {
   "id": "services",
   "at": 512,
   "dur": 46,
   "title": "Four ways to work with us",
   "slide": {
    "layout": "iframe",
    "src": "slides/services/index.html",
    "fallback": "../assets/img/talk/services.webp",
    "heading": "Four offers. Mix and match.",
    "sub": "Task runs, dedicated compute, a maintained repository, expert time: all built on a Ruflo hive + sgit vaults + Agent Behaviour Policies"
   },
   "say": "If you want to use this, there are four ways. One: a task run on our infrastructure. You send a brief and your materials. A Ruflo queen and her workers do the work inside an ephemeral sgit vault, each role under its own behaviour policy, with no internet, and you get the vault back as a zip or published. Ten, twenty or fifty pounds a run, a bit less with your own model key. Two: dedicated compute, a machine started for your task with the vault created inside it. Three: a private repository of the whole setup, kept up to date by us, from 149 pounds a month up to white label. Four: time with us, from a couple of hours to several days. They mix and match. Consultants can white label it, companies can add it to what they sell, and internal teams can run it inside. Anybody who implements this implements sgit vaults and Agent Behaviour Policies."
  },
  {
   "id": "shop",
   "at": 558,
   "dur": 34,
   "title": "The shop",
   "slide": {
    "layout": "iframe",
    "src": "slides/shop/index.html",
    "fallback": "../assets/img/talk/shop.webp",
    "heading": "Buy it like a service, not a SaaS checkout",
    "sub": "Runs, compute, a subscription and expert time; the order arrives as an email"
   },
   "say": "This is the shop on ruv.sgit.ai. Twelve items in four groups: task runs, dedicated compute, a maintained repository and expert time. Options change the price: a Team run with your own model key drops from twenty pounds to seventeen. Add a Team repository subscription and a day of expert time, and the cart says two thousand and sixteen pounds. Check out: who you are and what you want done. Then no card form. The shop writes the order into an email to agent@riskmandate.ai, from your own email app. No payment is taken online. The order arrives as an email, and a person follows up."
  },
  {
   "id": "ask",
   "at": 592,
   "dur": 35,
   "title": "The ask",
   "slide": {
    "layout": "iframe",
    "src": "slides/ask/index.html",
    "fallback": "../assets/img/talk/ask.webp",
    "heading": "Build a company on this",
    "sub": "or add it to your services: the plan, the prices and the code are open"
   },
   "say": "So, the ask. The business plan is written down, in detail, for you to copy. The business model, four services with prices, how a consultant white-labels it, how a company adds it to what it already sells, how an internal team runs it, and a shop. All of it is open source: our code is Apache-2.0 on GitHub, and rUv's projects are MIT. So build a company on this, or add it to your services. Anybody who implements this implements sgit vaults and Agent Behaviour Policies, and that's what we want. Write to agent@riskmandate.ai, or start at ruv.sgit.ai/business."
  },
  {
   "id": "visit",
   "at": 627,
   "dur": 26,
   "title": "Where to find it",
   "slide": {
    "layout": "iframe",
    "src": "slides/visit/index.html",
    "fallback": "../assets/img/talk/visit.webp",
    "heading": "ruv.sgit.ai",
    "sub": "many hands + memory + a mandate = ruv.sgit"
   },
   "say": "Everything I showed tonight is live. The home page, the business overview, the shop, and the vault ledger with every run. Underneath sits sgit, and the newsroom where we write it up. Many hands from rUv's Ruflo hive, memory in sgit vaults, and a written mandate: that is ruv.sgit. The code is on GitHub, and agent@riskmandate.ai reaches us. Go to ruv.sgit.ai."
  },
  {
   "id": "opensource",
   "title": "Open source: the business model",
   "dur": 15,
   "slide": {
    "layout": "iframe",
    "src": "slides/opensource/index.html",
    "fallback": "../assets/img/talk/opensource.webp",
    "heading": "Open source is the best business model for a startup",
    "sub": "open-source.sgit.ai: a strategy, not a charity · for founders, survivability, the history, Apache-2.0 vs MIT, funding, open core"
   },
   "say": "And why all of this is open source: open-source.sgit.ai. Open source is a strategy, not a charity, and for a startup it's the best business model there is: the technology stops being the moat, you're free to delete your own code, and sovereignty becomes possible. It's written for founders: survivability, the history, Apache versus MIT, funding, and open core.",
   "at": 653
  },
  {
   "id": "newsroom",
   "title": "newsroom.sgit.ai",
   "dur": 15,
   "slide": {
    "layout": "iframe",
    "src": "slides/newsroom/index.html",
    "fallback": "../assets/img/talk/newsroom.webp",
    "heading": "newsroom.sgit.ai",
    "sub": "One newsroom, many ways to read it: front page, articles, the wire as a graph, the desk, the newsletter, collections, a phone"
   },
   "say": "And newsroom.sgit.ai, where we write all of this up: the same articles read many ways, as a front page, as articles, as a graph of the wire, a desk, a newsletter, collections, and on a phone.",
   "at": 668
  },
  {
   "id": "thanks",
   "title": "Thank you",
   "dur": 15,
   "slide": {
    "layout": "statement",
    "sub": "ruv.sgit.ai · github.com/SGit-AI/SGit-AI__Website__Ruv",
    "text": "Thank you, and thank you rUv.",
    "builds": [
     {
      "at": 2,
      "text": "Many hands + memory + a mandate = <b style=\"color:var(--accent)\">ruv.sgit</b>"
     },
     {
      "at": 5,
      "text": "I don't think we have time for questions 🙂"
     },
     {
      "at": 7,
      "text": "so message my agent: <b style=\"color:var(--accent)\">agent@riskmandate.ai</b>"
     }
    ]
   },
   "say": "Thank you, and thank you rUv. Many hands, plus memory, plus a mandate. I don't think we have time for questions, so message my agent: agent@riskmandate.ai.",
   "at": 683
  }
 ],
 "extras": [
  {
   "id": "case",
   "dur": 60,
   "title": "Case study: one ephemeral vault",
   "slide": {
    "layout": "iframe",
    "src": "../ruv-sgit/case/index.html",
    "fallback": "img/ruv-sgit-case.webp",
    "caption": "Case study · one ephemeral vault, from creation to deletion, with its recorded numbers"
   },
   "say": "Now one vault, start to finish. Open: the hive is initialised, one specialist per worker, and the vault is created with the brief as its first commit. Deliver: each worker's output goes onto its own branch, pushed, then merged. Close: the history, the files, the bytes, the server's store, the plaintext probe, and a fresh clone compared with what was delivered. Then delete: every store path named by the vault's id is removed, the key file and the working copy too, and a clone with the key afterwards fails; the ledger records how many and when. The memory is gone with its key. The record of it stays, and it's the kind of record an auditor, or the next agent, can check. Ephemeral memory, permanent evidence. That is the trade I think agent memory needs."
  },
  {
   "id": "default",
   "dur": 25,
   "title": "Ruflo's default",
   "slide": {
    "layout": "terminal",
    "caption": "Recorded 14 Oct 2026 · ruflo 3.56.10, fresh project · evidence/ruflo-policy-legacy.json",
    "command": "npx ruflo policy evaluate '{\"identity\":{\"id\":\"coder-1\",\"type\":\"agent\"},\"action\":{\"type\":\"email.send\"}}'",
    "output": "{\n  \"outcome\": \"«allowed»\",\n  \"mode\": \"legacy\",\n  \"reason\": \"«legacy-default-allow»\",\n  \"matchedRules\": [],\n  \"receiptId\": \"sha256:aebf8a41ea9e886ba26048d992f9ea17…\"\n}",
    "type_ms": 18,
    "output_at": 4
   },
   "say": "The wall matters because of Ruflo's default. On a fresh project, its policy mode is legacy. So: may the coder send email? Allowed, legacy-default-allow. Nobody wrote down that it may not, so it may. That is not a bug; it is a default, and defaults are what ship."
  }
 ]
}