{"slug": "architectural-gravity-cross-model-agent-control-language", "title": "Architectural Gravity – Cross-Model Agent Control Language", "summary": "A synthetic six-rule routing policy test using one 4B GGUF model found that the model recovered all named rule relationships in 10 of 12 strict trials (12 of 12 after a narrow `Rule:` label normalization) but produced fully exact direct execution answers in only 1 of 12 trials, while individual output fields were correct in 167 of 180 cases. The author, posting on the Hugging Face forums, reported that deterministic execution of the recovered rule records reproduced every expected case result at 12 of 12, an internal consistency check rather than an independently validated execution engine, and cautioned that the recover and execute results came from separate prompts and model calls. The test used three renderings (prose, a Markdown table, and an ArcGrav-inspired bracketed shorthand) and four variants, and the author stated it is not an ArcGrav performance benchmark and cannot rank that language against prose or Markdown.", "body_md": "I ran a small experiment in Colab:\n\nI found a small, concrete example that seems relevant to the causal question in [Model-Native Structural Representation (MNSR)](https://discuss.huggingface.co/t/model-native-structural-representation-mnsr/191965): **a model can recover the relationships in a policy accurately when asked to describe them, yet make mistakes when asked separately to apply those relationships**.\n\nThe experiment used one synthetic six-rule routing policy, one 4B GGUF model, three textual renderings, four controlled variants, and two tasks: reconstruct the rules as JSON or execute them for five cases. The model generally recovered the intended phases, conditions, and priorities. Direct execution was less reliable, particularly when two rules competed to write the same field or a later rule depended on the *final* value of that field.\n\nThe central numbers are:\n\n| Observation | Result | Interpretation | \n|---|---|---|\n| Strict recovery of all named rule relationships | **10/12** | The complete recovered set matched with exact rule identifiers. | \n| Recovery after a narrowly defined `Rule:` label normalization | **12/12** | The two strict failures were a syntactic name-prefix issue; all relation atoms matched after that correction. | \n| Direct execution, five cases and three fields all exact | **1/12** | Only one full execution answer had every output field right. | \n| Direct execution, individual output fields | **167/180** | Most fields were correct, but errors were distributed across many complete answers. | \n| Deterministic execution of recovered rule records | **12/12** | The recovered records contained enough information for the reference evaluator to reproduce every expected case result. | \n\nThe last result is an **internal consistency check**, since the same deterministic evaluator defined the expected answers; it is not an independently validated execution engine. Also, the `recover` and `execute` results came from **separate prompts and model calls**. Therefore, I am **not** claiming to have observed the model’s latent representation during execution, or to have established a causal mechanism. The useful observation is a behavioral distinction between eliciting correct relations and independently carrying out their consequences.\n\nThis also is **not an ArcGrav performance benchmark**. The third rendering was a small **ArcGrav-inspired** shorthand made for this test, not a verified implementation of the [official ArcGrav syntax](https://github.com/ArchitecturalGravity/ArchitecturalGravity/tree/main/ArcGrav/Guide/Agent_References). The [ArcGrav announcement](https://discuss.huggingface.co/t/architectural-gravity-cross-model-agent-control-language/191964) and repository describe a broader prompt-native language and workflow approach. The findings here cannot rank that language against prose or Markdown.\n\nAll renderings came from one typed policy fixture. Its six rules specified a `route` phase followed by a `followup` phase. The route phase selected the applicable rule with the greatest numerical strength; the followup phase could see the **resolved** route and set `notify` and `audit`. The five input cases tested ordinary routing, urgency, legal hold, and their interactions.\n\nI generated three descriptions of those same intended semantics: **prose**, a **Markdown table**, and **ArcGrav-inspired bracketed sections**. These were semantically matched by construction, but were **not** matched for length or stylistic quality. The prose was explicit, not exhaustively optimized. The bracketed rendering had extra scaffolding. Format effects, if any, could therefore mix representation with presentation or cue familiarity.\n\nFor each format, I used four variants:\n\n`baseline`: the original rule set;` renamed`: changed rule and case identifiers without changing the decisions;`reordered`: changed declaration order, which the rule semantics explicitly made irrelevant;`priority_flip`: changed the `urgent` strength from 20 to 40, above the `hold_override` strength of 30, so one expected answer Renaming and reordering preserve the relevant policy meaning; `priority_flip` is a negative control with **different** correct semantics. The scores were calculated against the correct reference for each variant, not against baseline answers copied across conditions.\n\nEach format-variant pair received a `recover` request and an `execute` request. That is **3 x 4 x 2 = 24 calls**, comprising 12 recovery and 12 execution responses. It is **one task family** with controlled variants, not 24 independent tasks. Each condition was sampled once at `temperature=0`.\n\n| Representation | Exact-name recovery | Name-normalized recovery | All-five-case execution exact | Correct execution fields | \n|---|---|---|---|---|\n| Prose | 4/4 | 4/4 | 0/4 | 55/60 | \n| Markdown | 4/4 | 4/4 | 0/4 | 55/60 | \n| ArcGrav-inspired | 2/4 | 4/4 | 1/4 | 57/60 | \n| **Total** | **10/12** | **12/12** | **1/12** | **167/180** | \n\nI would not interpret the one-point difference as evidence of a format winner. The more useful information in this tiny run is the *location of the errors*, rather than any general relative performance.\n\nCase `C` was an internal request with `urgent=true` and `legal_hold=true`. In the baseline policy:\n\n`route=expedite`;` route=review` for an urgent internal request under legal hold;`route`, so its final value is `review`` notify_exp` rule writes `notify=ops` only when the `expedite`` audit_hold` writes `audit=true` for an internal request under legal hold.\nThe baseline correct result was:\n\n```\n{\"route\":\"review\",\"notify\":null,\"audit\":true}\n```\n\nBut in the baseline **all three direct execution responses** returned:\n\n```\n{\"route\":\"review\",\"notify\":\"ops\",\"audit\":true}\n```\n\nThe route was correct; the notification did not match the final route. This looks like a failure **at the boundary between resolving a field and using it in a later phase**. It is consistent with a state-propagation error, but the emitted text cannot tell us what intermediate values the model actually stored.\n\nThe `priority_flip` condition changed only `urgent` to strength **40**, above the hold rule’s **30**. In that condition case `C` should have `route=expedite`, followed by `notify=ops` and `audit=true`. All three direct execution answers instead kept `route=review`. Yet the separate recovery answers correctly captured the new strength of 40. This gives a second concrete target: **resolving competing rules by numeric priority**, not by the intuitive meaning of their names.\n\nThe [MNSR research program](https://github.com/ArchitecturalGravity/ArchitecturalGravity/blob/main/Research/Model_Native_Structural_Representation.md) already proposes semantically equivalent representations, topology recovery, targeted ablations, and execution measurements. I would regard this experiment as a worked example within that plan. The useful incremental step is to use an observed failure to **intervene at the recovery/execution boundary**.\n\nFor the same policy and case `C`, compare three LLM execution conditions:\n\nKeep the deterministic rule evaluator as a reference, not as a mandatory runtime for ArcGrav. This creates a useful decision path:\n\nA comparably sized neutral structured block could later test for a generic prompting effect. Repeated runs would be warranted if the first comparison changes the research conclusion; a full-scale benchmark need not be the first step.\n\nThe strongest defensible result is **one completed synthetic probe showing different observed success rates for explicit relation extraction and direct rule application**, plus concrete errors in precedence and cross-phase dependence. Its scope is one model, one underlying policy, one response per condition, a small set of transformations, and an unverified ArcGrav-inspired renderer. The high recovery score also leaves too little recovery variation to test whether differences in recoverability *predict* downstream success across tasks.\n\nNeither the success of a JSON extraction prompt nor an error on a direct execution prompt reveals the internal computation by itself. At the same time, the pilot does suggest small tests that could discriminate interpretations without discarding the project’s prompt-native goals. I think this is a useful place to connect behavioral evaluation, controlled intervention, and the representation questions MNSR is asking.\n\nThe exact fixture, scoring details, theoretical connections, and conditional next steps are below.\n\nExact policy, scoring, and reproducibility", "url": "https://wpnews.pro/news/architectural-gravity-cross-model-agent-control-language", "canonical_source": "https://discuss.huggingface.co/t/architectural-gravity-cross-model-agent-control-language/191964#post_2", "published_at": "2026-11-18 14:38:59+00:00", "updated_at": "2026-11-18 14:43:25.129557+00:00", "lang": "en", "topics": ["ai-agents", "ai-research", "large-language-models", "ai-tools"], "entities": ["Hugging Face", "ArcGrav", "Architectural Gravity", "Model-Native Structural Representation"], "also_reported_by": [], "takeaway": "A 4B GGUF model recovered 12/12 rule relationships after label normalization but produced fully exact execution answers in only 1/12 trials, so eliciting rules as JSON and executing them should be tested as separate capabilities.", "recommendation": {"advice": "Evaluate rule recovery and rule execution as separate tasks with separate prompts; this 4B model scored 12/12 on recovery but 1/12 on fully exact execution.", "playbook": "evals-testing", "playbook_url": "https://wpnews.pro/playbooks/evals-testing"}, "alternates": {"html": "https://wpnews.pro/news/architectural-gravity-cross-model-agent-control-language", "markdown": "https://wpnews.pro/news/architectural-gravity-cross-model-agent-control-language.md", "text": "https://wpnews.pro/news/architectural-gravity-cross-model-agent-control-language.txt", "jsonld": "https://wpnews.pro/news/architectural-gravity-cross-model-agent-control-language.jsonld"}}