CodexinginAgent

The machine was already there.

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 packages one reusable skill: $graph-relational-coding.

The lake keeps its dimensions

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.

The Hacker's Path

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.

The Binder Test

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.

What it refuses

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.

Install

Share this repository:

https://github.com/Xananthium/CodexinginAgent

Install it:

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

What ships

.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/

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.

Lineage

CodexinginAgent is the Codex-native continuation of Xananthium/Graph-Relational-Coding-Agents, preserved from upstream commit 604c7010e5957045269977e2f12629f3ab7b9020.

MIT licensed. See LICENSE.