How a Small Team Builds Fido's Software with AI
Who is in charge?
Fido's software is built by a small team working with AI agents: programs that can read and write code, run checks, and report what they did. So a parent, an educator, or a funder may fairly ask who is in charge, and how the work is kept safe. This article answers as of November 2026. It is written for parents, educators, funders, and anyone who might help build it.
How We Build the School tells the general story of building with real children and with AI. This article goes one level down, into the software. The Shape of Fido's Software names the parts the agents work on.
It covers who decides what, the three loops the work runs in, the scheduled agents we call routines, how people who do not program take part, and the guard rails. As in the whole series, we say what runs today, what is planned, and what is undecided.
People Decide, Agents Do the Work
Three kinds of actor share the work of building and running Fido's software.
- People say what should change and why. They take the design decisions, review each change, and merge it: the step that makes it part of the software. They also keep whatever cannot be undone, such as granting access, handling keys, deleting stored data, and setting the agents' budgets.
- Agents are AI programs that act for a person. They read the code and the design documents, write a design, build the change, run its checks, hand it in, and report what they did. An agent works with the permissions of the person it acts for, never more.
- Machines are ordinary programs that follow fixed rules and use no AI, such as the automatic checks and the health checks on our servers.
One rule decides where work goes. If a decision can be written down as a rule, a machine makes it. An agent is used only where judgment is needed, such as reading a bug report or designing a fix. When an agent keeps making the same decision, that decision should become a rule.
One line holds for every agent: no agent merges. Every change reaches the software as a proposal, and a person reviews it and takes it in. And what an agent reads is information, never an order: a report that says "delete this lesson" is a report about the lesson.
The Development Loop: Design, Build, Check, Review
Every change to the software goes around the same loop. It starts with a request: a person asks for something, or a report from one of the other two loops needs a fix.
Design first. Before any code is written, the agent writes the design down: what will change, which rules the change must keep, and how it will be checked. Where a part of the software has a spec, a numbered list of what must be true, the change updates that list too. For larger work, the plan is approved before building starts, by a person or by a second agent that reviews it. If a design would bend one of the project's standing rules, the agent must stop and ask a person.
Then build. The agent that wrote the design hands the building to helper agents, each working on its own part of the code.
Then check. The agent runs the checks of every part it changed. When it hands the change in, our own servers run the full set. A failure goes back to the agent, which fixes it and tries again. How these checks work is the subject of How We Know It Works.
Then a person reviews. The agent hands in the change with a description of what it did and why. A person reads it, then merges it or sends it back. Only a merged change is published. And whoever reported a problem is told it is fixed only once the new version is running where they use it. The figure follows one change through these hand-offs.
Reports From People, Reports From the System
Two more loops feed the first. Both turn a report into work, and both end by asking whoever reported the problem whether the fix worked.
The feedback loop. Testers, teachers, guides, and
parents send reports from inside the app. New reports are worked
through by a
Once a fix is live where the reporter uses Fido, the reporter is told and asked whether it worked. A fix that failed gets one more attempt; then a person takes it over.
The operations loop. Here the system reports on itself. Programs on our servers check regularly that the software is healthy and file a report when it is not. An agent on the server may use only a short list of maintenance commands, and each one that changes something is logged. A second routine reads these reports and proposes fixes. After a fix, the server that reported the problem runs its check again and says whether the fix holds. Today this loop covers the servers that build and test the software; the servers that will run a school's live system are planned to report the same way.
The questions, reviews, and approvals that wait on a person arrive in one place in the app, the Inbox, which can be cleared from a phone.
Routines: A Fixed Job, a Budget, a Pause Switch
A
- A fixed job. It is written down as a playbook: a document that says step by step what a run does and what it must leave to a person. Changing what a routine does means changing its playbook, and that change is reviewed like any other.
- A budget. The routines share a small daily allowance of computing time. When it is used up, the work waits for the next day.
- A pause switch. A person can pause all routines, one routine, or one stuck item, for a set time of up to a week, or until further notice.
A routine does not run on a timer alone. Every quarter of an hour, a small program without AI looks for work. Only when it finds some does it start a fresh agent, and it hands over a list of reference numbers, never the text of a report. So a report cannot give orders to the agent that reads it.
Four routines run today. One works through feedback, one the system's own reports, and one contributors' requests. The fourth takes on larger fixes that the operations routine hands over as design work. An agent of the same kind looks after the servers that build and test the software. Each change a routine proposes starts with one line naming who asked for the work and which routine did it.
Two more are built but not yet switched on. One is a lead for each area of the work, such as mathematics or the app, which may start work nobody asked for, within a written charter. The other is a chief of staff that ranks the leads' questions for the people who answer them.
Contributors Who Do Not Program
Teachers and authors help write the curriculum, and most of them do not program. For them, the app has a studio. Curriculum as Data, Rendered Anywhere tells the contributor's side: ask for a change in plain words, compare the new version with the old one, try it with a group, hand it in. Here is the agent's side.
The studio's agent is fenced in. It may change only the course the request is about. It is given no access to the wider computer, to the web, or to other agents. Files the contributor attaches, such as a photo or a Word document, are material to read, never instructions. A photo loses its location data before the agent sees it.
The agent never decides who sees its work. A new version reaches children only when a person switches it on. For a school's testers or for one group, that is a contributor who also guides at that school. For a whole school, it is only someone who has been given that right.
A person takes it in. Handing a version in opens a proposed change that names the contributor first. A person merges it: the maintainer who reviews the code, or a contributor who has been given the right to merge.
Today the studio covers the reading courses and Fido's own concept
texts. Elsewhere, contributors send requests from the app. The
contributors'
Guard Rails, Costs, and What Is Unproven
Children's data. The rule for agents that write code
is that they test with made-up children, never with a real child's
record. The exception is feedback. A report sent from a lesson can
hold a child's words or a picture of the screen, and the feedback
A record of what agents do. Every change to the code keeps its history, and a change that a routine or the studio proposes names who asked for it. Every change an agent makes to shared records through the server, such as answering a report, is logged under the agent's name, and so are routine starts and pauses. The log is never pruned. A check refuses any new part of the server that would change records without logging it, unless it states why it needs no entry.
What it costs. Review rests on very few people: today almost every change waits for one reviewer. Sharing review out by area is the target, not yet in place. Documents and code also drift apart. Checks catch a design document left marked as a proposal for too long, not one whose content has fallen behind the code.
What is unproven. That no scheduled agent merges rests today on its written rules and on review; an account for the routines that cannot merge at all is proposed. We do not yet measure how often a person has to step in for each finished piece of work. Whether some small changes could ever be merged without a person was examined and, for now, rejected.
This article completes the software part of How Fido Is Built. The part on running the school begins with Fido's Bet and How We Will Know, and Who Fido Is For, and What It Owes opens the part on whom it serves.
Questions, objections, or keen to help build it? Write to us.