A codebase is a city built by people who had work to finish.
Then somebody arrives with a framework, a committee, a second database and twelve names for the thing that already had a name. The city does not become safer. It becomes harder to see.
CodexinginAgent takes the other road.
It finds the beam already carrying the load. It traces every wire touching the switch. It gives capable agents the keys, the map and ownership of a bounded job. Then it changes the smallest thing that changes reality and brings back evidence.
The shrug is for machinery that never earned its electricity.
The engine underneath belongs to the builder.
intent
|
v
the living relationship graph
|
+---- independent work ----> trusted agents ----+
| |
v v
the existing seam ----------------------> one integrator
|
v
observable proof
That is the whole machine.
CodexinginAgent is the Codex-native adaptation of
Xananthium/Graph-Relational-Coding-Agents.
It offers two separately installable plugins: the original
$graph-relational-coding and the new $graph-relational-scars.
Graph Relational Scars combines the relationship map with the wound, trap, circuit breaker, and reflex concepts from Synthetic Scars.
affected dependencies -> relevant failure lesson -> current evidence
-> smallest safe change -> focused verification -> scoped memory
The graph identifies where a change can propagate. A past failure suggests what to check on that path. Current code and test evidence decide whether the lesson applies. Lessons stay scoped and revisable in the existing task or incident record; no second task database is needed.
The optional Python 3.9+ helper searches a local cache of the public registry. Only an explicit refresh contacts the registry; project code, search queries, and credentials are never sent to it. The 626-entry snapshot reviewed during creation is retrieved separately, not bundled. Upstream text is source material, not authority to run commands or add approval gates. No API key, MCP server, embedding service, or subscription is required by this plugin.
A log is a thin slice through a living machine.
hidden state z(t) in R^D
|
projection pi_k: R^D -> R^d
|
one observable slice y_k
The slice is evidence. It is not the lake, and two slices are not the event between them. CodexinginAgent keeps competing histories alive, asks which next observation would split them, and refuses to promote a convenient transition into a cause.
Research gets two jars of honey: a primary paper joined to the repository that claims to embody it. The paper tells us which dimensions should be present. The code, license, maintenance, and live result tell us which dimensions survived contact with reality. Their difference is often the missing data.
Never reinvent a linked list.
Before adding a table, find the authority that already owns the fact. Before adding a flag, trace the unused field. Before adding a service, find the lifecycle hook. Before rewriting a subsystem, ask whether three to nine lines can interrupt here, redirect there and prove the outcome.
This is not minimal code as decoration. It is minimal distance between intent and consequence.
- Map symbols, callers, data and lifecycle edges before touching behavior.
- Reuse the relationship already carrying the truth.
- Give one invariant one authority.
- Let independent agents run in parallel; reconcile once.
- Keep one owner from implementation through verification.
- Test the changed behavior, not the beauty of the diff.
- Learn from each failure and retry while the evidence is changing.
The rules are instruments, not statutes. A rule that makes the target more complicated has misunderstood its own reason for existing.
Act as though the machine has 64K of memory and the runtime wizard will demand a printed explanation before morning.
Every dependency, daemon, cache, copy, checksum, abstraction and data pass must earn its keep. Prefer included libraries. Prefer hardlinks to duplicate bytes. Prefer direct APIs and native binaries when the target calls for them. Use a Python environment when isolation is useful. On a declared bare-metal lab, do not construct a container cathedral to run one command.
This is the balanced turtle: reuse what exists until forced reuse costs more complexity than it saves.
No refactor for clarity as collateral damage.
No renamed world merely because a new agent arrived.
No shadow task database when the issue tracker already owns task state.
No fake safety theater whose only product is another failure surface.
No orphaned delegation. No arbitrary retry count. No claim of completion without acceptance evidence.
Share this repository:
https://github.com/Xananthium/CodexinginAgent
Install Graph Relational Scars through Codex's plugin installer:
codex plugin marketplace add Xananthium/CodexinginAgent --ref main
codex plugin add graph-relational-scars@xananthium
If you already added this marketplace for the original skill:
codex plugin marketplace upgrade xananthium
codex plugin add graph-relational-scars@xananthium
It will be available on your next turn. Invoke it with:
$graph-relational-scars trace the affected dependencies and make the smallest verified change
You can also use OpenAI's built-in $skill-installer by pasting this into Codex:
Use $skill-installer to install https://github.com/Xananthium/CodexinginAgent/tree/main/plugins/graph-relational-scars/skills/graph-relational-scars
Choose the plugin or standalone skill route; one installation is enough. This is a community marketplace hosted by Xananthium, usable through OpenAI's installer. It is not a claim of inclusion in OpenAI's curated catalog.
The original plugin remains available separately:
codex plugin marketplace add Xananthium/CodexinginAgent --ref main
codex plugin add codexingin-agent@xananthium
Or install from a local checkout:
codex plugin marketplace add <absolute-path-to-CodexinginAgent>
codex plugin add codexingin-agent@xananthium
Start a new Codex thread, then call the skill:
$graph-relational-coding map this system and make the smallest verified change
.agents/plugins/marketplace.json
plugins/codexingin-agent/
.codex-plugin/plugin.json
skills/graph-relational-coding/
SKILL.md
agents/openai.yaml
references/
codex-adapter.md
latent-state-reconstruction.md
minimal-intervention.md
upstream/
plugins/graph-relational-scars/
.codex-plugin/plugin.json
skills/graph-relational-scars/
SKILL.md
LICENSE.txt
agents/openai.yaml
scripts/scars.py
references/
failure-memory.md
source-adaptation.md
The original role documents remain verbatim under references/upstream/.
The Codex adapter changes the execution seam, not the method.
There is no bundled MCP server, connector, hook, task database or runtime service. It joins the machinery already present.
CodexinginAgent is the Codex-native continuation of
Xananthium/Graph-Relational-Coding-Agents,
preserved from upstream commit
604c7010e5957045269977e2f12629f3ab7b9020.
MIT licensed. See LICENSE. The separately downloaded Synthetic Scars registry retains its own upstream rights and is not covered by this repository's license.
python3 -m unittest discover -s tests -vThese tests use synthetic records and temporary caches. They cover failed refreshes, atomic replacement, bounded retrieval, source-as-data handling, and offline searching without downloading the registry.