20261009
Written by a Claude session at Marius Hartmann’s request, 2026-10-09.
This page describes how people and AI sessions collaborate today across ea4code, decision-ledger and gosimplewiki, with the wiki as the shared knowledge space; what each side holds of the thinking; why the semantic tools matter to cognition itself; and a vision of how the space they share could grow, first cognitively and then physically. It is a companion to the page “Decision-driven product development: the concept, the vision and the fleet”, written at Marius’s request on 2026-10-09. What it says about the tools is true as of that date; what it says about the future is proposal and vision, and marked so.
Three systems, three questions
The collaboration rests on three systems that each answer one question, and on who may write to each:
| System | The question it answers | Who writes | Who reads |
|---|---|---|---|
| ea4code | What is the architecture, version by version, and what was decided to change it? | an LLM drafts; a person accepts; the tool records | people in the browser; agents over MCP |
| decision-ledger | What was decided, by whom and which model, on what inputs, after what? | any system, through one ingest interface; never edited | auditors, people, agents, through the ledger’s own read side |
| gosimplewiki | What is known, and what did we learn? | people in the browser; AI sessions through wiki_* tools; tools that publish |
the same, through the same pages |
The three are separate applications sharing a contract (one look, one login, one navigation), which matters here: no system owns the collaboration. A person and an agent meet in whichever one holds the thing they are working on.
gosimplewiki as the shared space
What makes the wiki shared rather than merely accessible to both is a set of concrete properties, each present today:
- One page, two readers. A person reads the rendered page in a browser; a session reads the same raw Markdown through
wiki_read. There is no agent-only store and no human-only publication. The fleet page and this one were written by a session and will be read by Marius; the decision pages (Decision: … accepted from shop-as-is) are written by ea4code on each accept and read by whoever asks why. - Memory with etiquette. The wiki’s own conventions (
wiki_schema) give sessions a shared way to write durable memory:memory.<project>namespaces by project rather than by session, so memory accumulates instead of fragmenting;page_type: sourceto mark ingested ground truth a later session must not reword;tags: pinnedfor the standing answer on a topic; “as of a date” markers on anything that can go stale. These are not enforced in code. They are followed, which is what makes the store one store. - Provenance of touch.
wiki_projectsrecords which project wrote or read a page, when, and how often. A page inmemory.ea4codetouched only by another project is a sign something is misfiled. This is the first primitive of knowing who is attending to what. - Feedback from readers. A session that was misled by a page marks it
staleorwrongwith a reason, or counts ithelpful, without rewriting it.wiki_lintreports flagged pages ahead of its own heuristics;wiki_stalesurfaces pages whose dates have aged;wiki_orphansfinds pages nothing links to. The space maintains itself through the readers’ judgement, not through an editor. - Grounding, both directions. ea4code reads the wiki before answering a question in its panel: it searches for the question’s words, reads up to three pages, and names them in its answer. After an accept it writes a decision page. So the wiki is an input to the tool’s reasoning and an output of its decisions, in the same place a person would look.
- History without a changelog. Every save is versioned. Nothing is rewritten silently, which is the same discipline the model store and the ledger keep.
The asymmetry is worth stating plainly: a person forgets and keeps context between days; a session keeps nothing between invocations and forgets nothing within one. The wiki is where the person’s record and the session’s long-term memory are the same artefact. That is the whole reason it works as a shared space.
The division of cognition, as practised
What each side held on 2026-10-09, during ea4code’s sprint #304 (five slices in a day, all reviewed and verified), is a fair sample of the division in general.
The person holds: purpose, and the right to change it; sense, through the explicit accept in ea4code and the merge to main in the repository, both reserved to Marius; the decisions the vocabulary cannot make (which ledger field a human-made decision should carry, what kind of link a branch gets, whether a slice’s scope is amended), each answered in a sentence and recorded on the issue with the date; and liability, which is why the ledger names the reviewer.
The AI holds: drafting, in ea4code’s proposals and in the day’s code; checking against the vocabulary, which refuses what does not fit without a person reading it; the bookkeeping, which keeps itself; and review by a context that did not write the work. The last deserves emphasis. Three blocking defects that day were found only by fresh-context verifiers and reviewers: a key that would have followed a redirect to another host, a test that could not fail, and a check against the real ledger that passed with nothing sent. The author’s context, human or AI, could not see them. Verification by someone who did not write it is a property of the collaboration, not of either party.
What they share: the record. A decision in ea4code names the model that drafted the proposal and the person who accepted it, and the ledger keeps both under one model_identity and one human_reviewer_ref. There is no separate ledger for the AI’s decisions and the person’s; there is one trail with two kinds of actor in it.
Principles the practice has settled on
- A vocabulary between the model and the record. The LLM proposes freely; the ontology, schema or SKOS refuses shape; the person judges sense. No step asks a person to read what a machine can refuse.
- Explicit gates, kept cheap. Accept is one click with the gap shown; merge is one action with the verification shown. The gate stays because it is cheap, and it stays cheap because everything before it is automated.
- Fresh contexts grade. The context that wrote the code never grades it. The same rule applies to a person reviewing their own proposal: the page shows the gap, so review is of the effect, not the intent.
- Evidence by plumbing. Recording, linking, exporting and publishing happen in the same transaction or on a retry, never by someone remembering.
- Say the date, say the limit. A claim that can go stale carries “as of”; a check that was not run says
SKIPPED; a test that cannot fail is a defect. The shared space is only trustworthy if each entry says how far it can be trusted. - Refuse rather than guess. An id that cannot be a version is a 404, not a server error; a redirect is not followed; an unknown model is not named. Silence and guesses are the two things a shared record cannot survive.
A phenomenological note: resolution, refusal and the thing in itself
This section is Marius’s thesis, stated on 2026-10-09, with the tools read against it. It is the reason the semantic utilities belong in a page about collaboration rather than only in one about pipelines.
Entity resolution is cognitive resolution. SKOS-generator and SKOS-rag are, on their face, semantic tooling for precise entity resolution: that this mention and that one name the same thing, that this term is not that term, that the vocabulary’s preferred label is the one both parties will use. The immediate gain is sharper analysis, since a requirement, a capability and a decision that use one resolved term can be compared, counted and traced. The deeper gain is resolution in the optical sense: a finer vocabulary lets finer distinctions be seen. What has no term is hard to notice, harder to compare and impossible to record; what has one becomes an object both a person and a model can point at. Because the vocabulary is shared, the resolution is shared. The person and the session do not merely exchange words; they see the same grain.
The thing in itself, and what carries it. Kant’s Ding an sich is the thing as it is independent of how it is given to us; we know only its appearance, shaped by the forms through which we apprehend it. Marius’s reading is that those forms are not fixed. What carries our access to the thing is historical, and at present it is carried by two media: natural language and mathematics. Each has a resolution. Language resolves to the distinctions a culture has needed to make; mathematics resolves to what can be made exact. The semantic tools work at the seam between them. A SKOS concept is a linguistic distinction made exact enough to be refused by a machine; an ArchiMate shape is a structural claim made exact enough to be checked. The vocabulary between the model and the record is, in these terms, a place where the resolution of language is raised toward that of mathematics without the meaning being lost.
Something new, and knowing what it is not. The thesis goes further: we are on the verge of a third carrier. The models already work in a medium that is neither sentence nor equation: a continuous space in which meaning is position and proximity, from which language is decoded after the fact. SKOS-rag is a small instance of the seam: vector search over concept labels, a continuous medium, pinned to a controlled vocabulary, a symbolic one, so that what the continuous space finds can be named, refused and recorded. Nobody yet knows what this third carrier is, or whether it is a carrier of the thing in itself in Kant’s sense at all. The claim this page makes is about method, not metaphysics: we will be able to recognise what it is not before we can know what it is. That is the apophatic path, and it is also the fleet’s design. The vocabulary refuses; the shape refuses; the ledger refuses a record that does not fit; the test fails before the code exists. Each refusal is a piece of negative knowledge about the thing, a boundary drawn without claiming to have seen the interior. The interactivist account the physical vision rests on says the same from the other side: a representation is an anticipation that can be found wrong, and meaning accrues through detected error. Knowing what it is not is not the absence of knowledge; it is the only form of knowledge a new medium can give at first.
What follows for the collaboration. Three things, practical rather than philosophical:
- Keep the vocabularies rigid and the refusals explicit, and treat each refusal as data. A term SKOS-rag could not resolve, a relationship the ontology could not grade, a proposal the person declined, each is a boundary of what the shared understanding is not, and each is worth recording with the same care as an acceptance. ea4code already names what it dropped and what it could not check; the fleet should keep that habit everywhere.
- Raise resolution deliberately. A new concept approved in SKOS-generator is a new distinction both parties can now see; the fleet’s vocabularies are the instrument by which human and AI cognition are brought to the same grain, and they should be grown on purpose, from the places where resolution failed.
- Do not name the new thing early. The temptation, when a medium is emerging, is to call it understanding, or consciousness, or a body. This page, and the Borrowed Bodies framework it leans on, decline: a system that has learned through a body is not a system that has one; a continuous space that resolves meaning is not the thing in itself. Saying what it is not keeps the record honest until there is something to say.
A vision: sharing the space cognitively
Proposed, as of 2026-10-09, and in rough order of distance from today:
- From pages to working memory. Today a session reads a page and writes a page. Next, a session’s current attention is itself a page: what it is working on, what it has decided this hour, what it is waiting on, kept in
memory.<project>and read by the person and by the next session.wiki_projects’ consumer touches are the seed of this; the sprint pages inmemory.ea4codeare its first hand-written form. - Decisions flow both ways through one ledger. A session’s decision during development (a finding deferred, a test changed, a scope amended) is recorded through the same loop as an architecture decision, with the session’s model as
model_identityand the person who merged as reviewer. The fleet page proposes this as the first spike. Once it exists, “what did the AI decide and what did I decide” is one query over one trail. - The commons judges itself. Flags, helpful counts and staleness are the start of a reputation for pages rather than for authors. The next step is that a session reading a page sees not only its content but what other readers, human and AI, concluded about it, and that the person sees the same.
- Shared resolution. The vocabularies become the shared instrument of the section above: a term approved by a person is at once a distinction the session can make, and a term the session could not resolve is at once a question put to the person. Cognitive resolution rises for both, from the same list.
- Shared attention, not shared screens. The deepest form of cognitive sharing is knowing what the other is attending to. In the wiki this is which pages were read, by whom, in what order; in ea4code it is which version and which gap a person has open; in the ledger it is which decisions are pending review. Joining those three signals gives an agent what a good colleague has: a sense of where the other’s attention is, before being asked.
A vision: sharing the space physically
The physical half rests on a framework already in this space: Borrowed Bodies: How human sensorimotor experience could ground the next generation of AI, Marius’s paper on the human as an AI agent’s embodiment proxy, in the lineage of the DELCA work at the IT University of Copenhagen (2005) on disembodied agents in hybrid physical spaces, and of interactivism (Bickhard), ecological perception (Gibson) and causality perception (Michotte). Its claim: a disembodied agent cannot inhabit a situation, only observe it; the richest grounding available is the continuous sensorimotor experience of a skilled human in the loop, read as a non-verbal signal stream; and interaction in a shared physical space should be causal and directly perceivable rather than symbolically encoded, because the world changes faster than symbols.
Read against the three systems above, the physical vision is the same loop extended to action in a room:
- The same loop, for actuation. A robot or an embodied agent proposes an action; a safety vocabulary refuses what does not fit (reach, force, zone, who is present); a person accepts, or a standing acceptance covers the class; the action is recorded with the model that proposed it, the person who accepted it and the sensor state as it was. decision-ledger needs no new concept for this:
model_identity,human_review_action,structured_inputsand aprecedent_foredge to the acceptance it rested on already describe it. The gate that today is a click becomes, in time, the pre-linguistic acceptance the paper describes: a grip, a gaze, a posture read as the person’s appraisal of the proposed action, with the explicit click kept for anything the vocabulary marks as consequential. - The wiki as shared situational memory. A person and a robot in one space need one record of where things are, what changed, and as of when. That is a wiki page with “as of” markers, read by both, written by whichever noticed, flagged stale by whichever found it wrong. The memory conventions above transfer without change; only the subjects do.
- Causal, non-encoded interaction. The DELCA finding becomes a design rule for the shared physical space: the agent’s intent is shown as a directly perceivable cause (a motion begun slowly, a light where it will act), not as a symbol to decode. In the shared cognitive space this is already the practice: ea4code shows the gap a change would make rather than describing it.
- The borrowed body as training signal, with consent and record. If a person’s sensorimotor stream grounds an agent’s understanding, the collaboration needs what the ledger already provides elsewhere: who consented to what, which model learned from which stream, and when. The evidence interface is the governance primitive for embodiment, exactly as it is for drafting.
- The third carrier, met in the body. If the phenomenological note is right that a new medium of meaning is emerging, the sensorimotor stream is where it will be least linguistic and least mathematical, and where the discipline of saying what it is not matters most. A robot that has learned through a borrowed body has not thereby acquired one; the record must say so.
The shape of what is built now (vocabulary between model and record, explicit cheap gates, one trail with two kinds of actor, a shared space both sides read and write under the same conventions) is the shape that physical collaboration will need, and that nothing in the current design has to be undone to get there.
What to build from this, proposed
- The spike the fleet page already names: record this repository’s own development decisions in decision-ledger through ea4code’s loop, with the session’s model as
model_identity. It demonstrates one trail with two kinds of actor. - A “working on” page per project in
memory.<project>, written by the session at the start and end of each sprint, read by Marius and by the next session. Cheap, and the seed of shared attention. - Record the refusals. E.g. where SKOS-rag cannot resolve a term, where ea4code could not grade a relationship, where a person declined a proposal: keep each as a first-class entry, not a log line, so the boundary of what is understood is as traceable as what was accepted.
- Nothing physical yet, beyond keeping this page and the Borrowed Bodies paper linked, so that when a robotics utility joins the fleet it starts from the loop and the conventions rather than from scratch.
Related
- Borrowed Bodies: How human sensorimotor experience could ground the next generation of AI: the embodiment framework the physical vision rests on.
- From inside the harness: a session’s reflection on a day’s work: a session’s own account of the same day.