Tech as we know it has always had gatekeepers.
For much of its history, the gate was practical: only people with the skills, capital, and access could build software, so only they decided what it did and who it served. Over time, the gate became a business model. Black-box systems, user lock-in, opaque platform algorithms, and unaccountable governance let private tech companies capture and control user behavior for their own benefit.
Communities that want digital programs to tackle their hardest problems, from child protection to climate resilience, are left on the wrong side of the gate. They can build their own technology and keep their independence, but must find the skills, capital, and expertise to do it. Or they can use private platforms, and give up ownership and agency.
The gate is about to swing open. Not because big tech has suddenly developed a conscience, but because the black box itself can finally be opened.
Every digital system runs on two kinds of rules.
The black-box code gate
- The rules of logic: what information the system holds, and how it makes decisions.
- The rules of control: who can see what, who can change it, and whose knowledge counts.
In almost every digital system, neither set of rules is visible to the people who use it. The logic is locked in code that only its builders can read, and that even they struggle to understand and change once it’s written. As the computer scientist Peter Naur argued, code records the outcomes of design decisions, not the reasoning behind them: not the options weighed, the ones discarded, or the ones never considered at all. Nor does it capture the values, blind spots, or motives of the people who wrote it.
The rules of control are harder still to see. Some sit in a platform’s software, in permissions and settings kept apart from the content they govern. The rest are held by the team behind the platform: their design choices, the hierarchy that decides who has permission to change what, their business priorities, their institutional memory. Most of it is never written down. Code has no place to hold it, and the organization has no incentive to include it.
This forces communities into an impossible choice.
- Inherit a platform built and controlled by someone else, and a community gains continuous innovation. But its people become passive consumers, working on someone else’s terms, unable to understand, let alone challenge or change, the rules.
- Invent its own technology, with open-source software and custom development, and a community gains ownership. But it starts from scratch. It needs skilled talent and deep subject-matter expertise, and it’s cut off from the evidence and expertise behind proven programs, the very things it would need to build something of comparable quality.
Either way tech retains its exclusivity, keeping the gate firmly locked against meaningful grassroots impact and innovation – and potential competitive alternatives.
Code as data: an old idea that was ahead of its time
The way out of code’s black box has been understood for decades: take a system’s logic out of code and express it as data that people can read. This idea, often called “code as data,” is not new. It’s also an idea, I know from experience, that means little to the average person. I generally get glazed eyes when I try to introduce this concept. In everyday terms, black-box code is like being handed a finished cake. Code as data is being handed the recipe, written so you can read it, tweak it (a little more salt! A bit less sugar!), and bake your own – or adapt it entirely for your gluten-free friend who also just doesn’t really like dairy.
Lisp programmers were treating code as data as far back as the late 1950s.
Model-driven engineering (engineers design a system’s logic as a model or diagram, and software generates the code from it, e.g., Simulink) and low-code platforms (business employees build an application through visual editors, forms, and specs, e.g., Microsoft Power Apps) describe applications as models and configuration rather than handwritten code.
Rules engines and decision standards separate decision logic from software so it can be read and audited (e.g., OpenFisca, which expresses tax and benefit rules as open, structured code). The semantic web and knowledge graphs structure data so that it carries its own meaning (e.g., Wikidata).
In the social sector, tools like ODK (an IDEMS favorite, and a key part of our open-source stack!) let people build applications through forms and configuration.
All moved the field forward. But none of them has truly opened the black-box code gate.
Two problems have held them back.
The first problem is authoring. Structuring a system’s logic and meaning as data is hard, expert work. Creating and maintaining that structure at scale demands specialist skills, so the people able to do that work simply become a new class of gatekeepers. (This is the way the current tech landscape works: each new innovation that enables more agency in one way introduces greater dependency and lock-in in other ways.) The promise of systems anyone can understand, build, and rebuild was ultimately undermined by their complexity and the rare expertise required to make them usable and useful.
The second is forking. These approaches work when everyone converges on one shared design. But the moment a community adapts the design to its own context, its new version splits away. It can no longer receive updates from the original, and its improvements can no longer flow back. Adapting still means forking, and every fork is a costly island that requires skilled upkeep, or inevitably loses its usefulness and dies the quiet death of irrelevance.
Why now: the most gatekept technology is about to open the gate
The technology most locked behind the gate – contrary to nearly all current prognostications, which suggest it will be more exclusive, more controlling, more extractive than anything we’ve ever seen before – is about to become the very thing that opens it. Today’s frontier AI is built by a handful of companies, trained on data no one outside them can audit, and opaque even to its builders. Yet it is poised to solve the problem, authoring, that stalled code-as-data innovation for decades – and not because anyone set out to solve it.
Large language models can now make sense of structured data in systems too complex for any human team. That changes who can work with structure.
With AI assistants that are narrow, bounded, and auditable, a local NGO or a community leader can adapt a structured program without writing code or mastering a data model. The assistant handles the structure; people remain in control of the adaptation at the level of intent, data, or code syntax that their contextual situation demands. The expertise that once made structured systems a specialist’s domain is no longer a barrier to using them.
This is the irony of the AI moment. Today’s generative AI is itself the ultimate black box: statistical analysis applied to data at enormous scale, in systems AI companies themselves don’t fully understand. But the same AI, paired with systems whose logic is expressed as meaningful, structured data, becomes the tool that finally makes that logic accessible to everyone. The AI does the translating and sensemaking. The deterministic structure keeps it honest.
AI is already breaking the tools built for human-paced software, but so far only in ways that don’t seem designed to serve most humans. Within weeks of each other, two of the big AI companies announced they had outgrown Git, the version control system most of the software world runs on. Last month (October 2026), Anthropic replaced it with Scion, its own system, after AI-driven code merges grew from about 2,500 to more than 30,000 per day in four months. And just this week (November 2, 2026), OpenAI unveiled Pando, a Git-compatible backend built in about ten weeks with help from its own coding agents, and now serving nearly a petabyte of code data a day. Their approaches differ: Anthropic left Git behind, while OpenAI kept compatibility and is contributing improvements back to the open-source project. But both solve the same problem, the need for a single codebase to absorb change at unprecedented speed. I can’t argue with that for a single company. But for communities, the challenge has a very different profile: many owners, more and more versions, and the need for all of them to stay connected.
In contrast to all the doom-and-gloom prognostication, we (and when I say “we,” I really mean the brilliant mathematicians and mathematical scientists I work with, including the team at the Topos Institute) contend that the tool that opens the gate does not have to become the next gatekeeper. Quite the contrary: it can be used to route around the gatekeepers who built it, and open the gate for everyone.
AI solves the authoring problem. It does not solve divergence, and it does not touch the rules of control. That is the work IDEMS has spent eight years on, and it is where our CommonTech framework adds to and builds on the old idea of code as data to put communities at the center.
In an impact program that depends on both specialist expertise and community knowledge, CommonTech works in three layers:
- The Impact Brain, a knowledge core where expert program content and software, along with community practice and localization data, are held as structured, reusable data.
- AI Hands, narrow, auditable expert support agents that help local teams adapt the core to their context.
- The Impact Weaver, the community-adaptation hub where community stakeholders build their own local versions, and through which those versions stay connected.
Together, they add four key innovations to code as data. To go back to the cake: code as data hands over the recipe. CommonTech hands over the recipe along with the science behind it and the family feedback that shaped its perfection. Every adaptation, from a little more salt to gluten-free and dairy-light (including the context that demanded it – maybe it was a flour shortage during Covid, maybe it was a newly diagnosed allergy – and the adaptations that worked or didn’t and why), stays connected to the original, so a better version can find its way back into the family cookbook.
- Versions that differ and stay connected. CommonTech’s patent-pending semantic interoperability framework, grounded in mathematics (such as category theory, for those who want to dig deeper), structures a program’s content, software, and decision logic as data components that carry their meaning with them. Because every local version is built from the same meaningful components, applications built and owned by different organizations still understand each other, however much they differ. A local improvement can be compared, folded back into the expert core, and shared with other communities. Adapting no longer means forking.
- Rules of control that travel with the program. In CommonTech, the rules of who owns, governs, and protects each component are written into the data itself. Every piece carries its own record of who created it, who can change it, and who can see it, and those rules stay attached wherever it goes. Many owners can share one program without any one of them controlling all of it.
- Decisions anyone can audit. When a system’s information and decision-making logic live in data people can understand, anyone can see why it produced an output, and change it. Accountability stops depending on trust in whoever runs the platform.
- Independence from big AI. Because the structure carries the meaning of the data, the AI does not need to be large (more data, more compute, more data centers!) to have value. Over time, lean, small language models that communities run on their own servers, with their own data, can do the work. And that’s when the tool that opened the gate stops being a gatekeeper at all.
What it looks like in practice
The University of Oxford’s Global Parenting Initiative (GPI) developed a parenting program proven to reduce violence against children. Its impact depends on an ever-expanding network of stakeholders that GPI researchers can’t reach directly: local facilitators, parents, and NGOs, who hold the household context, the relationships, and the trust. At a cost of $120 per family, in-person delivery couldn’t scale. And a conventional app, with program, content, design, and functionality fused into one fixed codebase built by experts, would have to be rebuilt for every new context to achieve meaningful engagement and measurable impact.
ParentApp – built on very early, very prototype CommonTech foundations – separates those layers. The evidence-based program is held by GPI researchers and its NGO, Parenting for Lifelong Health. Only they can change the proven program. On top sit layers that others own and change independently: language and content by local partners, design by local teams, functionality by implementers, media and reminders by delivery partners. When the team in Tanzania learned what worked for local families, the app could be redesigned again and again without touching the core program. It works offline, with family data kept on the phone.
The same foundations proved reusable. When the research trial in Tanzania required a control app, we quickly and inexpensively built WASHApp (for safe water and hygiene practice) on the same localized engagement foundations, with the same design; only the program content was swapped. That let researchers isolate the effect of the parenting program itself.
In a cluster-randomized trial with 2,396 adolescents aged 10 to 17 and their caregivers, across 80 urban and rural communities in Tanzania, ParentApp cut past-year sexual violence against girls by 67% and past-month sexual exploitation of girls by 54%. Three in four families completed every module. It cost $6 per family, against $120 for in-person delivery, and every $1 invested saved $16 in health services.
Beyond gatekeeping
When a system’s logic and its rules of control live in data that many people can understand and alter, there’s nothing left to gate. People stop being passive consumers of technology built by others, for others’ purposes, and become participatory citizens of the systems that shape their lives.
Communities no longer have to choose between owning their technology and staying connected to frontier social program software and resources. They can build, rebuild, and adapt applications for their own context, audit the decisions those applications make, and share what they learn, while every version stays interoperable with the rest.
This is the usable, reusable knowledge commons, freed from fragmentation and enclosure: expert evidence and local knowledge live together in one continuously improving system, with experts safeguarding what works and communities owning what makes it fit.
The infrastructure of the AI era is being laid now, and what gets built in the next few years will shape who owns, adapts, and benefits from technology for decades. The age of tech gatekeeping doesn’t have to last. The tools to end it finally exist. Now we need the funding to build the alternative.