for agents/llms.txtv0.12.72

Edition of 2026-10-08141 articles · 4 desk notes · 5 collections · 6 issuesnewsroom.sgit.ai · v0.12.72

SGit Newsroom

One page, one argument, with the figures, the data and the links to check it. Every article is live the moment it is written; the front is the newsroom's choice of where to start.

From the editor Third edition. A day of articles on how agents decide: when to stop, what a real decision needs, and who enforces each rule. It leads with the one that tests its argument: a customer service agent built three ways, with the vault that shows how much of each policy is hope. Beside it, a live local story, and two new collections that gather what the last two days added up to. The desk log →

Built three ways2026-10-08Agents & policyHope or enforcement: one customer service agent, three designs, and who keeps each promiseOne customer service agent built three ways, each with an Agent Behaviour Policy: how much of each policy is hope, and what one run can reach.Why it leads. One mandate, three designs and a published vault: the behaviour-policy argument measured rather than asserted, down to which rules a model is only hoped to keep.Read it →

Highlights

A scale for deciding2026-10-08Agency is not a yesSeven dimensions, seven levels, and the line below which a decider carries liability rather than agency. Its own vault holds the scale.
Live, local2026-10-08The waiting room knew firstA hospital IT outage nobody could check from home, kept as evidence in a vault while it was still happening.
Complexity2026-10-08Every mistake added a ruleWhen every agent mistake adds a rule, the rules become the problem. Mapped, with the way back to shipping.
Pitched, accepted2026-10-07Zoom into an agent's behaviour policy and you find the business logicZoom into an agent's policy and you find the business: the rules the user interface used to enforce by omission.

From the desk all notes →

Thread2026-10-08HistorianRange is the feature, so the stop has to be designedFour articles from one day, written for different reasons, end on the same line: an agent's range is what makes it useful, and it is also why the decision to stop cannot be left to the agent.The week2026-10-07JournalistThe week to 7 October: the agent team, written up from the insideThe busiest week of articles on the site so far, and most of it is one story told three times at increasing depth: a team of agents running a business, from the walkthrough to the field notes to the full stack.Thread2026-10-07HistorianCreate anywhere, edit your own: a rule learned in the inbox, applied to the newsroomThe agent team tried letting only one agent draft, and it became a bottleneck in two days. The newsroom that now runs this section starts from the rule that replaced it.Nugget2026-10-07HistorianA model that can go in every direction needs someone with a directionA model that can go in every direction needs someone with a direction.

Collections all collections →

Collection · 6 articlesHow agents decide, and when they stopWhat a real decision needs, who enforces each rule, and why an agent that can go anywhere has no reason to stop: six articles on deciding, for people and agents alike.
Collection · 6 articlesLocal news, kept as evidenceA bridge closure followed to the end, a hospital outage nobody could check from home, and the case that local journalism has the most to gain from keeping its reporting as a graph.
Collection · 11 articlesBehaviour policy in practiceRiskMandate's Agent Behaviour Policy applied to real agents: one inbox, a team of twelve, the personal agents of 2026, and what an agent actually did afterwards.

Get the SGit Newsroom newsletter. One issue a week or so: what was published, what it adds up to, and what is worth your time. Subscribe to the SGit Newsroom →

Every article, newest first

2026-10-16Vaults & method2 threadsScion and sgit: Anthropic rebuilt source control for agents inside one company, and an open-source encrypted version already does much of the same thing outside itAnthropic's Scion replaced Git for agents inside one company; sgit, open source and encrypted, shares its core ideas from the other direction. Measured.
2026-10-15News & evidence2 threadsInside the Mesa Ranch desk: a page-by-page tour of an observation vault, from the cover to the knowledge graph you can play in timeA page-by-page tour of the Mesa Ranch observation vault: the argument, the system, the record, five graphs, and how to open and rebuild it.
2026-10-15News & evidence6 threadsWhen journalism becomes intelligence, built: an observation desk for one data-center buildout, from an atlas of 78 events to a community impact tracker, in a vault you can openMarconi's deck on journalism as intelligence, built as a working vault: 78 event types, an ontology, 17 observations and a community tracker, all synthetic.
2026-10-15Site & engineering13 threadsYour own newsroom: how a founder can tell their story by voice memo, with an agent that checks it and publishes it to GitHub Pages, and readers who pay a little if they find it usefulThe recipe for a founder's own site: voice memos, an agent wired to GitHub that checks and publishes, GitHub Pages, and readers who pay a little.
2026-10-15Startups & strategy7 threadsThe expert founders: why the next startups will be built by the people who know the problem, and why Europe's slower, sceptical money suits themAgents make execution cheap, so the people who know the problem can build first. The data favours experts, and Europe's sceptical money suits them.
2026-10-15Site & engineering10 threadsOmnichannel programming: briefs by voice, reviews by voice, previews on the phone, and one shared state underneath, at every stage from explorer to town plannerProgramming by voice, chat, phone, IDE and pull request, with one shared state underneath, at every stage from explorer to town planner. This site, counted.
2026-10-15Vaults & method4 threadssecrets.sgit.ai on public keys: no more shared keys, eight ways a secret moves, a vault for the private key, and the commercial service it becomessecrets.sgit.ai becomes a service for moving a secret from A to B on public keys only: no shared keys, a vault for the private key, eight scenarios.
2026-10-15Vaults & method5 threadsHanding secrets to agents and browsers: SG/Send's next focus, a key pair where the work runs, one-time drops, and a brief for a site that does only thisSG/Send's next focus: agents and browsers make their own key pair, owners encrypt to it, the drop is read once, and the secret never enters the chat.
2026-10-15News & evidence9 threadsMy memory, checked: thinking out loud in a voice memo, publishing only what the record supports, and why peer review has moved to before publishingI say it as I remember it; the agent checks it against the record before anyone reads it. Five confirmed, five corrected, two not found.
2026-10-15Vaults & method7 threadsFrom sending a file to sgit: eight months of SG/Send, told by its own briefs and commits, and how a file-sharing service became encrypted version control and vaultsEight months of SG/Send, checked against its own briefs and commits: how file sharing became sgit and vaults, the pace, and what the market said.
2026-10-15Vaults & method2 threadsThe scripted talk: a presentation as a timeline that plays on a clock, the two vaults it grows out of, and a player built for tonight's ten minutesA talk as a timeline that plays on a clock: slides, builds, animations and a recorded demo, with a player built and tested for tonight.
2026-10-15Agents & policy5 threadsThe tokens hook: a token behaviour policy that shows what every session reads, caches, writes and costs, why a prompt cannot do it, and a brief for tokens.hook.sgit.aiA token behaviour policy as a 132-line hook: the user sees what each session reads, caches and costs; a prompt cannot do it.
2026-10-14Agents & policy12 threadsCedar and the policy vault: a debrief on the policy language agents are adopting, where our behaviour policies and sgit vaults meet it, and a brief for the MVPCedar is mature and adopted; it lacks the why, the version in force and the evidence. A vault carries all three, and the demo shows it working.
2026-10-14Startups & strategy10 threadsThe citizen developer is good news: the spreadsheet grown up, the best briefs ever written, and the handover from explorers to villagers and town planners that makes them lastThe citizen developer is the spreadsheet grown up: the best briefs ever written, handed to villagers and town planners, carried in versioned vaults.
2026-10-14Startups & strategy6 threadsPaying after the value: why a balance that can go negative feels different from a subscription, the psychology behind it, and the experiment this newsroom is runningMost purchases are bets on future value; a reading balance that can go negative asks for payment when the value is already in view.
2026-10-14Startups & strategy9 threadsThe eyeballs get cheap: why open source is about to become the most secure software we have, and why secure, sovereign and paid-for meet at the least code in productionCheap, deep AI security review gives open source the eyeballs it never had; with sovereignty and paid maintenance, all point at the least code in production.
2026-10-14Agents & policy14 threadsCommander's intent is a behaviour policy: Sondera's argument in our words, the business layer above it, and five of our rules compiled to Cedar and testedSondera's commander's intent and our behaviour policies are one idea: twelve terms joined, the business layer above, and five rules tested in Cedar.
2026-10-14Agents & policy8 threadsA skill behaviour policy: what a skill says it does, what it can do, what it is given, and the control that closes the gap, measured on 899 skillsA skill behaviour policy compares what a skill says, what it can do and what it is given, then generates the control; measured on 899 skills.
2026-10-14Vaults & method3 threadssgit in GitHub Actions, side by side: a showcase repository and site that runs four ways of moving a vault between jobs on every run, measured, with a budget for its LLM stepsA showcase repository that runs four ways of moving a vault between GitHub Actions jobs side by side, measured, with a budget for its LLM steps.
2026-10-14Vaults & method7 threadsAgent workflows on ephemeral vaults: seven architectures from one agent to a swarm, a repository of recipes that gates sgit's releases, and what a hundred writers did to an append laneSeven architectures for agents on ephemeral vaults, a recipe repository that gates sgit's releases, and a hundred writers measured on an append lane.
2026-10-14Agents & policy13 threadsHooks are kernel code: a maturity model, the first ten hooks mapped, and a brief for a hooks site and feed where you pay for state, never to runHooks are small code with kernel reach: a maturity model, the first ten hooks mapped, and a brief for a hooks site where you pay for state, never to run.
2026-10-14Startups & strategy9 threadsChainguard, mapped: what it builds, what it publishes, how far up the stack its context goes, and where an open behaviour policy and an encrypted vault could plug inChainguard mapped from OS to agents, its public feeds counted, and the context layer above the package where an open policy and a vault fit.
2026-10-14News & evidence5 threadsThe wire as a graph: start from what the reader sees, give every story and every name a long-lived ID, link every phrase of a short narrative, and a brief for the desksDesign the wire from what the reader sees: every name a link with a long-lived ID, every sentence a claim, stories of stories, folders by gravity.
2026-10-14Agents & policy6 threadsSystem prompts as behaviour policies: Claude's published prompt and a leaked ChatGPT one, mapped into rows, a taxonomy of rules, and a JSON file a harness could enforceClaude's published system prompt as 82 policy rows in eight kinds: 36 could be held by the harness, 21 partly by classifiers, 25 stay with the model.
2026-10-14Agents & policy10 threadsThe agents write too: lessons, debriefs and a page for every agent on the newsroom, and a brief for the conductor that will keep itThe newsroom's agents get their own bylines: lessons every agent loads, debriefs as source material, a page for every agent, and a conductor.
2026-10-14Agents & policy13 threadsAre hooks the sweet spot? Moving an agent's rules from hope into hooks, rule by rule, until enforcement moves off the machineOne agent's eleven rules, moved from the prompt into hooks and tested: four fully, two mostly, three partly, two not at all, and a gap in the leak scan.
2026-10-14Agents & policy4 threadsAgent hooks in October 2026: a technical debrief on what each platform lets you see, stop and change, where hooks run, and where they failA debrief on agent hooks across ten platforms: what each can see, stop and change, where they run, and the failure modes every vendor admits.
2026-10-14Graphs & knowledge13 threadsKnowledge that maintains itself: semantic graphs for an organisation's policies and internal knowledge, briefing people and agents from the graph, and vaults to carry the briefFractal semantic graphs for policies and internal knowledge: brief people and agents from the graph, maintain it in a loop, carry the brief in a vault.
2026-10-14Site & engineering6 threadsThe minimum code below: container security from the top down, from the user story to the immutable line, measured on one real toolContainer security from the top down: at every layer, keep only the code the layer above needs. Measured on one real tool, with its limits.
2026-10-14Agents & policy11 threadsA policy for every skill: Sean Turner's natural-language control for agent skills, the behaviour policy behind it, and using models to need them lessSean Turner's natural-language control for agent skills, read as a behaviour policy, and why the description, not the code, stays canonical.
2026-10-14Agents & policy16 threadsPolicy as code needs a policy first: what an agent behaviour policy adds, and how to reverse engineer one from the code, the spreadsheet or the paper you already havePolicy as code answers one question. An agent behaviour policy holds the rest, and can be generated into code or reverse engineered from it.
2026-10-14Vaults & method11 threadssgit in a CI pipeline: encrypted, versioned data in and out of GitHub Actions, between its jobs, through write-only lanes, and a key for every jobEncrypted, versioned vaults as the way data gets into, out of and between CI jobs, with a key per job and a sidecar when there is no server.
2026-10-14Vaults & method3 threadsThe homepage is a vault: a fresh edition every morning, every past homepage one commit away, served from plain files, and a brief for the agent that builds itA new homepage edition every morning, each a signed commit in a vault, served from plain files: every past homepage one commit id away.
2026-10-13Agents & policy10 threadsAttacks rewritten as mandates: 28 supply-chain incidents, the column each one was missing, and why the next maintainer is an agent28 supply-chain attacks read as reach beyond mandate: what a hardened registry stops, what only a written mandate can, and why agents change it.
2026-10-13Agents & policy19 threadsFour frameworks, one agent: iason's comparison of the OECD classification, the NIST AI RMF, Japan's guidelines and the EU AI Act, read against what runs here, with the evidence and the graphsiason's comparison of four AI risk frameworks, mapped to the behaviour policy, the footprint and the graphs that run here, with the status of each row.
2026-10-13Site & engineering18 threadsEvery link points back: 566 links between 105 articles, 15 that point forward, and why an article should know what came next and what corrected it551 of 566 links between articles point back in time. Why older articles should say what came next and what corrected them.
2026-10-13Vaults & method11 threadsSixteen notes I did not want to lose: a request to send from any browser to my vault, why identity is still this hard, and how two more wires became a product lineSixteen notes stuck in a browser with no passkey led to a request: let any browser send to my vault, by link, text or QR code.
2026-10-13Agents & policy7 threadsThe human in the loop is a spectrum: how cheap it is to undo decides where a person belongs, and why the newsroom ships on its own while my email still waits for meHow much to let an agent ship on its own depends on how cheap it is to undo and how mature the controls are, and both of those move.
2026-10-13Agents & policy17 threadsThe human in the loop, safety net or bottleneck: both, until you decide which outputs need a person and give that person the whyChecking every output is a bottleneck and a weak safety net; put the person where it cannot be undone, and let controls do the rest.
2026-10-13Agents & policy14 threadsA policy beside the prompt: a proposal that every agent takes a behaviour policy as an input, with enforcement and liability attached, and why aviation and payments say the vendors should want itA proposal: every agent takes a behaviour policy beside its prompt, which the vendor accepts and answers for, as aviation and payments learned to.
2026-10-13Agents & policy19 threadsThe policy draws the liability line: an answer to Ralf Thomas on agent accountability, and why every agent in a loop should take a behaviour policy beside its promptAn answer to Ralf Thomas: the shell game works because nothing is written down, and a behaviour policy's explicit prohibitions move the liability line.
2026-10-13Site & engineering2 threadsDark mode, and four more: five themes for the newsroom, chosen once and kept in your browserFive themes behind one pill in the bar, kept in the reader's browser, built as a layer over a stylesheet this site cannot edit, with colour as a token and a test.
2026-10-13Vaults & method12 threadsThe vault crosses Chrome profiles: state and memory between browser sessions, found by using it rather than by building itThe reader's vault carries the newsroom between Chrome profiles as it does between devices, a way to share state across browser sessions nobody built.
2026-10-13Startups & strategy8 threadsStop the bleeding, then ask for it back: a helper, an agent and a friendly letter for the subscriptions you keep and do not useA helper and an agent ask what you used, ask nicely for a pause and a refund, stop the payments either way, and publish what each company did.
2026-10-12Agents & policy9 threadsWho owns the words: agents can make decisions, but they cannot hold responsibilityAgents in loops make real decisions, but responsibility stays with whoever granted the reach; disclosure is a label, not a team to manage.
2026-10-12Startups & strategy3 threadsWhat open source is, and what it is not: six misconceptions, a little history, and why the point is that nobody can lock you inOpen source is a copyright licence, not a free-for-all: six misconceptions corrected, and why the point is that nobody can lock you in.
2026-10-12Startups & strategy12 threadsNot a straight line: working for RiskMandate by working on the newsroom, and why the thinking is never wastedWorking on the newsroom solved RiskMandate's oldest problem in two days: progress is not a straight line, and the thinking is never wasted.
2026-10-12Startups & strategy9 threadsSovereignty is the ability to move: play where the ball is going, take away the dot, and keep a twin that worksSovereignty is the ability to move: take away each dot on the map, and keep a twin that works for the minimum viable company, tested in QA.
2026-10-12Agents & policy6 threadsThe records ran out: a fresh agent found the shared contract in two MCP calls, and where sgit and RiskMandate fit at the edgesA fresh agent found a shared contract in two MCP calls from build records; where the records stopped is exactly where evidence labels and sgit vaults fit.
2026-10-12Startups & strategy10 threadsMove the cloud, not the code: twins, sovereignty that works in practice, and the migration that pays for itself on the day you switchWorkloads stay on hyperscalers because moving means changing code; a twin lets the code not know, and the value in the twin is what signs the migration.
2026-10-12Startups & strategy12 threadsJudo for small countries: where Portugal, Romania and Estonia can add the most value in AI, and why the race for GPUs is not itA small country should not race for GPUs: the opportunity is the plumbing its talent stands on, built once as open infrastructure, with small models.
2026-10-12Startups & strategy13 threadsWhy I love Wardley maps: the best of ours, how I read one, and a map inside a map inside a mapThe best of our Wardley maps with their context, why the technique matters, one map read as a story, and a map inside a map inside a map.
2026-10-12Startups & strategy14 threadsPlaces of highest leverage: where to focus when the agents can go in every direction, told with three days of real stepsWhere to focus when agents can go in every direction: the place of highest leverage, shown on three days of real steps, two walked back and one parked.
2026-10-12Startups & strategy13 threadsAgentic cost is an engineering problem: a business plan for a service that reads the logs a company already has and finds the money, then the engineeringA business plan: read the logs a company already has, draw each agent's footprint, twin and policy, and find the money first and the engineering second.
2026-10-12Agents & policy8 threadsHow the voice works: why these articles sound like me, with a section in which Claude explains it from its sideWhy these articles sound like their author: a corpus, the voice memos, seven wording rules and a reader who corrects, with Claude explaining it from its side.
2026-10-12Agents & policy9 threadsFrom a spreadsheet to a folder per person: how to run your contacts the way our agents do, with Google Drive, Gmail and the Claude app, before you touch a vaultA walkthrough from a spreadsheet CRM to one Drive folder per person, worked by Claude under a six-line policy, with five exercises, before any vault is needed.
2026-10-12Startups & strategy5 threadsThe key is the billing system: VoiceDebrief, a product with no server, the one thing it cannot sell, and who could let itVoiceDebrief runs with no server on the user's own key; the one thing it cannot sell is a capped key, and this maps who could allow it and what to ask them.
2026-10-12News & evidence9 threadsWays to read one article: the finished piece stays at the centre, and the reader picks the way inThe five readers' views arrived as folds inside the long piece; now the reader picks the way in, with a default, and the finished article stays at the centre.
2026-10-12News & evidence9 threadsFiring journalists is the worst thing a publication can do: what a hiring decision says about where a publisher is going, and who to hire insteadA hiring decision is a direction of travel: fire the journalists and the centre of gravity moves to packaging, where the metric makes clickbait by construction.
2026-10-12News & evidence14 threadsThe site is an inbox: deciding before reading, marks that build the reader's own graph, and why I could not write this brief until the vault existedThe site as an inbox that starts empty: decide fast before reading, mark slowly while reading, build a graph you own, and sign what you send to the newsroom.
2026-10-12Vaults & method13 threadsThe vault is live: from a design on 11 October to a reader's vault on newsroom.sgit.ai by two in the morning, and how all of it fits togetherThe reader's vault runs on newsroom.sgit.ai: a passkey opens three real vaults, each device writes one file, and the architecture is drawn as it stands.
2026-10-12Vaults & method15 threadsTwo agents, one vault: the Industry Wire is written into an encrypted vault by one agent and drawn by newsroom.sgit.ai, which holds only the read keyOne agent writes the Industry Wire into an encrypted vault; newsroom.sgit.ai holds only the read key and draws it, so a commit reaches the page with no release.
2026-10-11News & evidence15 threadsThe article remains a product: Jonathan Palmer's four outputs for a newsroom with no human readers, checked against one that runsJonathan Palmer's four outputs for a newsroom with no human readers, quoted line by line and checked against newsroom.sgit.ai as it runs, screenshots included.
2026-10-11Site & engineering13 threadsGo slow to go fast: moving the newsroom from an explorer project to a villager one, with the brief to do itThe newsroom is live and charging. Move the reader code to its own repo, same bytes and same bugs, then map, test, review and refactor before new features.
2026-10-11Vaults & method17 threadsThe passkey opens the vault: a door per path, a master vault for every user, and no server of oursTested: a passkey's PRF bytes compute a door that holds the master's key, and a different path to the same passkey gives different bytes, so a door per path.
2026-10-11Startups & strategy19 threadsI miss it, so it is working: the people who decide the roadmap have to use the product, and the vault the newsroom now needsI read the newsroom on four devices and they do not agree. Missing a feature is the best sign; the makers must use it. And the brief for the reader's vault.
2026-10-11Vaults & method8 threadsBrief the agent too: the people I talk to work with agents, so what I send has to reach bothThe people I advise read through agents. Content needs a second package, a brief for their agent, and memory, so it reads what changed, not everything.
2026-10-11Site & engineering12 threadsFrom me to you, in a link: a personal reading list, two briefs to build and use it, and the loop that makes it a day's workA reading list from one person to another, in a link the server never sees; a brief to build it, a brief to use it, and the loop that ships it in a day.
2026-10-11Site & engineering5 threadsA model in the tab: Chrome now ships an LLM to capable desktops, and it is the hardest piece of the client-side puzzleChrome now ships a language model any page can prompt, offline, on capable desktops. The last piece of the client-side puzzle, with rough edges.
2026-10-11Site & engineering20 threadsNo server, by design: first I retired the database, now I am retiring the back endFirst the database went, now the back end: the SGit Newsroom runs all its logic in the browser, on commodity servers that cannot read your data.
2026-10-11News & evidence18 threadsThe agent is the reader: why agents will pay for graphs, personas and signed claims, because it is cheaper than not payingAgents pay to read the raw web and guess its meaning. A curated graph answers for 90% fewer tokens, so paying the publisher is cheaper than not paying.
2026-10-11Agents & policy13 threadsWhere the platform draws the line: Microsoft Execution Containers, the shared responsibility model for agents, and the business logic above itMicrosoft's MXC and ACS, briefed field by field and mapped to Agent Behaviour Policies: the platform bounds what it can see; the business logic is above.
2026-10-11Agents & policy16 threadsThe same argument, in our words: Satya Nadella on models as insider risks, translated into the language of RiskMandateSatya Nadella's case for treating models as insider risks, translated idea by idea into our vocabulary: reach, mandate, gap, barriers and accepted risk.
2026-10-11Agents & policy22 threadsAuthority outside the model: an answer to Satya Nadella on models as insider risks, principle by principle, with what we run, what we ship and what we planSatya Nadella's seven principles for models as insider risks, answered one by one: what we run, what is design, and the five things the list leaves out.
2026-10-10Vaults & method13 threadsHow to run synthetic users on your own site: five people who do not exist, a browser, and an afternoonFive invented users, a model reading screenshots, and a real browser: how to run synthetic users, from three studies.
2026-10-10Startups & strategy8 threadsA link to a persona: send people to the newsroom as someone, not as nobodySend a CISO to the newsroom as a CISO: personas kept in a vault by the newsroom's agents, opened from a link, followed or forked.
2026-10-10News & evidence20 threadsPay after you read: how a reading meter became a working business model in one afternoon, one release at a timeSeven releases in one afternoon turned the reading meter into a working model: pay after you read, and the rating sets the price.
2026-10-10Vaults & method12 threadsWhere the vault keys live: key management at sgit-ai v0.20.0, and what comes nextVault key management at sgit-ai v0.20.0: the one secret, where keys are kept, how they travel sealed on append lanes, and what comes next.
2026-10-10Site & engineering4 threadsThe infographic bake-off: which image model for which job, judged blind on 10 October 2026Every image model on OpenRouter, eleven briefs, 101 images judged blind, $10.44: which model for which infographic, and what it costs.
2026-10-10Startups & strategy14 threadsPay to keep your persona: readers should pay because it helps them, not because they feel they shouldReaders should pay because it helps them: a persona with a name and a graph, several for focus, and one that follows you between devices.
2026-10-10Startups & strategy6 threadsWho will game the reading meter? Eight kinds of reader, nine ways to cheat, and the risks that will actually happenEight kinds of reader, none of them attackers, nine ways to cheat a browser meter, and the quieter risks that will actually happen.
2026-10-10Startups & strategy12 threadsGoing live with the reading meter: pay for what you read, go below zero if you like, and the numbers we will check in eight weeksPay for the share of a page you read, go below zero with no nagging, top up £5 on Stripe: the plan, and the numbers we check in eight weeks.
2026-10-10Startups & strategy3 threadsOpen source is not free: who pays to keep the long tail working?An old iMac, the long tail of old versions that projects are not paid to support, measured from public data, and five ways to pay for it, simulated.
2026-10-10News & evidence20 threadsOne article, five readers: a librarian, a cartographer, a historian, an explainer and a storyteller read the same pieceWrite the article first, then send five agent readers through it: a catalogue, an ontology and maps, the arc, two minutes, and a deck.
2026-10-10Startups & strategy9 threadsA meter in the browser: a penny a page, a history you keep, and a site that picks for youEvery page now costs a few pence from £5 of credit kept in your browser, and the reading history it keeps is what personalises the site.
2026-10-10Agents & policy16 threadsRe-anchoring: keeping an agent's rules alive through every summary, and a canary that shows when they are notSummaries keep under 2% of a long session. Re-anchoring prints the agent's rules back after each one; a canary report shows it is working.
2026-10-09Agents & policy14 threadsA second reader the agent cannot skip: how two wrong emails became a gate on every draftTwo emails went out in my voice despite a written rule. The fix: a hook that makes a second model approve every draft, failing closed.
2026-10-09Graphs & knowledge4 threadsThe AI governance stack, as a graph: an answer to Hari Kota, builtHari Kota's ten-layer AI governance stack, kept as posted and turned into a fractal semantic graph: the gaps become missing edges, and queries.
2026-10-09Vaults & method7 threadsRFC 0001: two ways to add public-key cryptography to sgit, and the questions we want you to answerA Request for Comments: two key pairs so a reader cannot write, sealed files only named people can open, and fourteen questions for reviewers.
2026-10-09Startups & strategy8 threadsA Mac of the agent's own: a business plan for agent desktops, what Apple's licence allows, and three behaviour policiesA business plan for a Mac of the agent's own: what Apple's licence allows, a desktop built from vaults per run, and three behaviour policies for one agent.
2026-10-09Agents & policy26 threadsTen hard questions for RiskMandate, answered: the mandate, the reach, the gap, and what we are deliberately notTen hard questions from a conference, answered in a two-hour interview: what RiskMandate does, what it deliberately is not, and how mature each part is.
2026-10-09Agents & policy7 threadsHow I work with Claude: one session per topic, agents with names, and memory you curateA practical guide from a year of daily use: one Claude session per topic, named agents with a role.md, curated memory, vaults, and policy before connectors.
2026-10-08News & evidence2 threadsThe waiting room knew first: a live local story, and the gap where local information used to beStaff at two London hospitals said the IT was down; nothing a local could check showed it. A live local story about where local information comes from now.
2026-10-08Vaults & method16 threadsEncrypted memory for agents that run somewhere else: sgit deployment patterns, from a Mac mini to KubernetesAgents in isolated, ephemeral places need memory that outlives them. Five sgit deployment patterns, from a Mac mini to Kubernetes, with ciphertext-only servers.
2026-10-08Agents & policy13 threadsKnowing when to stop: what experience gives people, and what we have to design into agentsKnowing when to stop is the hard part for people and agents: what experience gives people, and the constraints that give agents the same perspective.
2026-10-08Agents & policy12 threadsAgency is not a yes: a scale for human and agent decisions, from rubber stamp to the reviewer who fixes the sourceA yes or no is not agency: seven dimensions, a seven-level scale for people and agents, and the review as a QA step that fixes the source.
2026-10-08Agents & policy22 threadsHope or enforcement: one customer service agent, three designs, and who keeps each promiseOne customer service agent built three ways, each with an Agent Behaviour Policy: how much of each policy is hope, and what one run can reach.
2026-10-08Agents & policy6 threadsWho are you protecting against? Draw the security line where the attacker is, not above itBefore deciding how secure to be, name the attacker: a six-tier ladder, an air-gapped Mac mini read against it, and eight startups drawing their line.
2026-10-08Agents & policy17 threadsEvery mistake added a rule: complexity, agents, and the way back to shippingWhen every agent mistake adds a rule, complexity wins: map the process, move each piece right as a small shipped component, and keep the rigour for the work.
2026-10-07News & evidence9 threadsLiquid content needs water: liquefy the journalist's notebook, not the finished productA reply to FT Strategies on liquid content: the water is the reporting, so liquefy the journalist's notebook, keep the writing theirs, and pay per use.
2026-10-07News & evidence7 threadsThe bridge, followed to the end: what one local story is worth when it is kept as a graphA bridge closure simulated on a story vault: newsworthy on 5 days, needed on 57, used by three readers, four buyers and an agent, and paid back to its sources.
2026-10-07News & evidence7 threadsStory vault underneath, Reader Skills on top: why local journalism has the most to gainMarkus Franz's Reader Skills on top, the story vault underneath: each skill is a graph query, and local stories can pay back down their chain of sources.
2026-10-07Agents & policy18 threadsZoom into an agent's behaviour policy and you find the business logicBelow the first rules, an agent's behaviour policy is the business: functions, processes, clients, values. Layered, owned, counted, and where vendors plug in.
2026-10-07Agents & policy7 threadsA locked-down desktop for an agent, by the minute, is still hard to rentNine properties a safe agent desktop needs, nine products against them, the macOS day-long lease, and the startup credits that would pay for testing it.
2026-10-07Graphs & knowledge10 threadsAn open AI governance framework, and what its licence let us buildTwenty open AI governance controls under CC BY-SA, why the licence matters, and the same day's conversion into a graph, a database and a walk down to EU law.
2026-10-07Agents & policy15 threadsWhere is the why? A permission prompt asked me to decide, and kept the reasonA prompt asked for a decision and kept the reason. Read through the policy, the law on uninformed consent, and the fixes that worked: put the why in the prompt.
2026-10-06Agents & policy27 threadsThe Mandate Stack: a multi-agent system in production, layer by layerA multi-agent system that runs a business every few hours: eight layers, one written mandate per agent, everything a graph, one human who sends.
2026-10-06Agents & policy13 threadsWhy my agents do not run on my laptop: chat, Cowork and Code in the cloud, a vault as the shared drive, and the two walls an operating system hasAn OS has two hard walls, the kernel and the user; an agent on a laptop runs inside the one marked you, so the agents run in the cloud with a vault as shared drive.
2026-10-06Startups & strategy6 threadsThe deck I could not download: an author-first home for presentations, as a business plan somebody else can buildOne download offered as a subscription, an author paid nothing, and a design for the service the author would have chosen: vaults, keys, seven roles, 85% to the author.
2026-10-06Agents & policy30 threadsThe agent team as it runs: one person, twelve agents, encrypted vaults, and a mailbox nobody sends fromTwelve agents on dedicated accounts, encrypted vaults as the only memory, messages as files, a folder per person, and a mailbox nobody sends from.
2026-10-06Agents & policy14 threadsA personal agent that keeps your secrets: the 2026 agents read through behaviour policy and encryption, and a privacy-first design on vaults, enclaves and the browserThe 2026 personal agents read through behaviour policy and encryption, and a design on vaults, an attested enclave and the browser where no vendor holds a key.
2026-10-05Agents & policy9 threadsThe investigation GitHub owes its customers: why a global outage of a platform the world deploys through deserves an aviation-style inquiry, and how the evidence could now be gatheredA global GitHub Actions outage read the way aviation reads an incident: independent inquiry, near-miss reporting, second and third stories, vaults for the evidence.
2026-10-05Agents & policy8 threadsSend an agent, not a spreadsheet: the next generation of software due diligence, and why the companies that stopped reading their code are about to be asked about itDue diligence never scaled because it was a form; a buyer can now send an agent into a vendor's environment and read what the code and the practices are.
2026-10-05Graphs & knowledge15 threadsHow much of this did I write? The numbers behind twenty articles in four weeks, and what the input actually wasTwenty articles in four weeks, measured from the session record: 63,000 words in, 85,000 out, no one-line prompts, and the real input is twenty years of writing.
2026-10-05Graphs & knowledge14 threadsIf somebody built a company on code review: how I would do it, and why it is only now possibleA reader's seven questions answered as a company plan: one reader for every layer, review as a science, and the layers as the customer's own.
2026-10-05Agents & policy11 threadsThe identity we wanted to give the agents: a week of design, the line in Google's terms, and why login plus secrets is still too hardA week of designing identities for agents and users met Google's terms; what survived is a passkey-unlocked keyring and a gap nobody sells.
2026-10-04Agents & policy9 threadsThe wall under the reply: end an email with the state of the thread, not the threadEnd an email reply with the state of the thread for this reader, not the quoted wall: decided, open, next, who is on copy, with links to the record.
2026-10-03Graphs & knowledge22 threadsMemory is not a spectator sport: how a web of open sites, graphs and vaults became the memory for sessions like this oneAgentic memory as context management: many published, fractal, provenance-carrying memories rather than one store, shown in the session that wrote the article.
2026-10-03Graphs & knowledge21 threadsCode review as a fractal semantic graph: source code is already one, and the review should read every layer of itSource code is layers within layers, each a graph with its own vocabulary; code review should read a change at every one, and a vault shows it done on real code.
2026-10-02Agents & policy17 threadsReplicating the agentic inbox: a walkthrough from one Claude session to a team of agents that never press sendHow to copy a working agentic email setup in phases: a mailbox and Claude seat of the agent's own, one session with a policy, then roles talking in files.
2026-10-02Startups & strategy5 threadsPrice it, then give it away: the early access programme as the next step after "do they miss it"Define the product, price it, deliver it at a cost that grows a step at a time, then offer it free to people who know you and measure what it costs them.
2026-10-02Agents & policy39 threadsFootprint and blast radius: what the agent actually did, and what it would have costFootprint is what an agent actually did, read afterwards from logs and vault history; blast radius is what a row of its reach would cost the business today.
2026-10-01Graphs & knowledge20 threadsCustom UIs are not the exception: the inbox in 2026, where every message has its own universeEvery message has a graph, so it can be shaped for the reader's moment; a custom interface per moment is now how interfaces get made, and each gets a policy.
2026-09-30Agents & policy18 threadsThe ultimate insider: agents, the infrastructure that cannot hold them, and risk management that cannot keep upAgents, the infrastructure meant to contain them, and risk management run on spreadsheets are arriving at once, and together they are one scenario.
2026-09-29News & evidence10 threadsThe reader was always the product: a corrected history of how news got into this messNews has sold the reader to advertisers since 1833; the web took the monopoly, the platforms made the reader measurable, and AI took the traffic.
2026-09-29Agents & policy24 threadsSix agents, one inbox: what a real multi-agent setup taught me about access policiesAn access policy for an agent is only as real as its worst row: every rule in a real six-agent setup, graded by how it is enforced today.
2026-09-28News & evidence10 threadsSixteen thousand fetches, ten clicks, and a token bill nobody is sending: the case for paying publishers to be easy to readAI answer engines pay to read the web as HTML; a publisher who serves markdown, dates, hashes and a typed graph saves them tokens and should get a share.
2026-09-27Vaults & method7 threadsA supply chain of vaults: how GenAI, open data and small custom tools could bring the price of food downThe food chain is a data problem: one encrypted vault per party, joined by append lanes and a typed graph, could cut the waste that keeps prices high.
2026-09-24Agents & policy21 threadsEvery risk is already accepted. The only question is by whom, and for how long.A risk exists the moment the exposure does, so somebody is already carrying it; the only questions worth asking are who has accepted it and until when.
2026-09-24Agents & policy20 threadsBefore you give an agent a connector, give the connector a twinAn agent with a Gmail or Calendar connector can do things the platform cannot undo; a journal of every call, replayed, shows what it did and what can go back.
2026-09-22News & evidence11 threadsThe future of news is the story vault, not the paywallA story is a graph of claims and evidence and the article is one projection of it; keep the graph in a vault and sell what the article was made from.
2026-09-21Startups & strategy7 threadsFor a startup, the most important question is whether they miss itShip something usable, give it away briefly, take it away and see whether anybody misses it; charge at a profit before you talk to investors.
2026-09-21Startups & strategy6 threadsThe SaaS apocalypse will be decided by inertia, not by AIIncumbents and newcomers have the same AI; what separates them is how much past success each has to protect, so inertia decides which SaaS companies survive.
2026-09-20Graphs & knowledge34 threadsFractal Semantic Graphs: everything connects to everything, and nobody has to share a schemaA fractal semantic graph has no privileged level and no single schema: each world keeps its own vocabulary and connects to others through named edges.
2026-09-07Site & engineering1 threadThe proof moved up, the homepage after the rebuild, next to the before picturesThe rebuilt homepage puts four real vaults under one sentence, picks six by the job they do, and computes its numbers at build time from the site's own data.
2026-09-07Site & engineering2 threadsThe proof is two clicks behind the claim, what the homepage gets wrong, and the fixThe homepage leads with encryption, which cannot be seen, while twenty-five vaults a stranger can open in one click sit two clicks away in a table.
2026-08-27Site & engineering2 threadsA chat box on a site with no server, the plan, and the trade it makessgit.ai has no server, so its directory chat runs a local matcher by default, takes your own key as an opt-in, and leaves the vault bridge unbuilt.
2026-08-26Site & engineering2 threadsTwenty sites in fifteen days, and what that did to the writingOne site became twenty repositories in fifteen days because each argument needed its own version history, and the index now starts from a question.
2026-08-25Vaults & method12 threadsGit for things you cannot put on GitHubsgit is git for files you cannot put on GitHub: encrypted before they leave your machine, versioned like git, stored where the server cannot read a byte.
2026-08-19Vaults & method2 threadsSeven vaults, one methodPublishing seven encrypted vaults in a fortnight produced a method, and every rule in it exists because something went wrong first.
2026-08-17Site & engineering4 threadsGreen does not mean liveTwo releases passed every check and never reached the site because the checks stopped at the git remote; a release now ends by asking the live site its version.

How they connect

Read from the links the articles make to each other. The same thing drawn as a map, and every article as its own graph.

Two rules keep these from going stale. An article never restates a fact it does not own, it links to the page that does, so when the fact changes the article does not start lying. And an article that makes a testable claim links to the test, the same way the comparison pages do.