Someone just dropped a project on r/ChatGPTPromptGenius called Architectural Gravity. At its center is ArcGrav, a small “Agent Control Language” you paste straight into a prompt. It’s brand new and has 2 upvotes, so treat it as an experiment worth poking at, not a proven standard.
What’s new
The idea is simple. When you write a long natural-language instruction, the model burns effort working out the structure: what’s context, what’s a rule, what’s the order of steps. Is that paragraph background info or a hard requirement? Does “after that” mean step three or a loose suggestion? Most of us have written prompts where the model gets one of those wrong, and then we spend ten minutes rewording. ArcGrav gives you named blocks for that structure, so the model reads it instead of guessing it.
You get named contexts like [Blueprint] and [Constraint], symbolic references, priority levels (P0 for the rule that must not break), and operations written as steps. Think of it like the difference between a messy email thread and a tidy spec sheet. Same information, but one of them tells you where to look. The author’s claimed benefits are lower token cost, fewer misreadings, less scope creep, and less drift over long contexts. Those are expected improvements, not results. The repo also ships AgMark, a benchmarking app, so you can test the claims yourself.
The twist
No runtime. No parser. No fine-tuning. The model has never been trained on this language. You paste it as ordinary prompt text and the models just follow it, because it borrows structural conventions they already know. Square-bracket headers, named references, numbered steps and priority labels all look familiar from config files, markdown, and code. The model recognizes the pattern and treats it as structure. That means there’s nothing to install, nothing to break, and nothing to maintain. If it doesn’t help, you delete the brackets and you’re back to plain text.
The mini-workflow (from the author’s example)
The demo is deliberately over-the-top. It spells “Hello World!” from twelve Unicode code points.
🧱 Put the data in a named block. [Blueprint] holds Char_01 through Char_12, each one a code point like U+0048. That one is the capital H, and the rest follow the same pattern for e, l, l, o, the space, W, o, r, l, d and the exclamation mark.
🏭 Define a reusable operation. [CharacterFactory] takes a value and returns a fresh record with the decoded character. Once it’s defined, you can call it as many times as you like without re-explaining what it does.
🔒 Set the rule. [Constraint] says P0: output only the assembled characters on one line. No greeting, no explanation, no “Here is your result.”
🔁 Write the task as numbered steps. Select the Char_* entries in name order AS [Codes]. Loop over [Codes], call the factory, append each result to [Message]. Output [Message] and follow [Constraint].
That’s the whole thing. Notice you never say “first do this, and please remember not to add commentary.” The structure carries it. If the model works properly, the output is just Hello World! and nothing else. If you see extra chatter, that tells you the P0 rule wasn’t weighted the way the author intended, which is useful data on its own.
Pro tips
- Don’t start with your biggest prompt. Take one prompt you reuse often and rewrite it in this shape. A weekly report generator, a code review checklist, or a summarizer you run every morning are all good candidates. Run old and new side by side on the same model.
- Count tokens on both versions. If the savings don’t show up in your own numbers, you’ve learned something cheap.
- Run each version several times, not once. Models vary from run to run, so a single good result proves very little. Five runs each gives you a much better feel for consistency.
- The repo has agent-readable reference folders for the language spec and the research. Feed those to your model first and let it help you convert your prompts.
- Keep the P0 rule short. One hard constraint beats five soft ones.
- Test on a second model too. If the structure only works on one, that’s worth knowing before you build a habit around it.
Worth knowing
The example is intentionally elaborate, so it shows the syntax rather than a real-world win. Spelling twelve characters this way costs more tokens than just typing the words, and the author knows it. The point is to show the mechanics in a case where you can check the answer at a glance. The big claims (consistency, less drift, faster throughput) still need independent testing. Good news: the project hands you the benchmarking tool to do exactly that.
Your move
Grab the repo (ArchitecturalGravity on GitHub), paste the Hello World example into your favorite model, then convert one of your own prompts and compare. If you get real numbers, share them with the community. Fair winds, crew ⚓
Architectural Gravity – Cross-Model Agent Control Language
by u/ArchitecturalGravity in ChatGPTPromptGenius