Skip to content

About

Codex-native graph-relational coding agents with minimal-intervention orchestration

Resources

Stars

2 stars

Watchers

0 watching

Forks

Latest commit

 

History

5 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

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 offers two separately installable plugins: the original $graph-relational-coding and the new $graph-relational-scars.

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.

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

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

Lineage

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.

Validate the registry helper

python3 -m unittest discover -s tests -v

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

About

Codex-native graph-relational coding agents with minimal-intervention orchestration

Resources

Stars

2 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages