# Architectural Gravity – Cross-Model Agent Control Language

> Source: <https://discuss.huggingface.co/t/architectural-gravity-cross-model-agent-control-language/191964#post_2>
> Published: 2026-11-18 14:38:59+00:00

**Recommendation:** 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.
More in the playbook "Evals and testing for LLM apps": <https://wpnews.pro/playbooks/evals-testing>

I ran a small experiment in Colab:

I 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**.

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

The central numbers are:

| Observation | Result | Interpretation | 
|---|---|---|
| Strict recovery of all named rule relationships | **10/12** | The complete recovered set matched with exact rule identifiers. | 
| 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. | 
| Direct execution, five cases and three fields all exact | **1/12** | Only one full execution answer had every output field right. | 
| Direct execution, individual output fields | **167/180** | Most fields were correct, but errors were distributed across many complete answers. | 
| Deterministic execution of recovered rule records | **12/12** | The recovered records contained enough information for the reference evaluator to reproduce every expected case result. | 

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

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

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

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

For each format, I used four variants:

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

Each 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`.

| Representation | Exact-name recovery | Name-normalized recovery | All-five-case execution exact | Correct execution fields | 
|---|---|---|---|---|
| Prose | 4/4 | 4/4 | 0/4 | 55/60 | 
| Markdown | 4/4 | 4/4 | 0/4 | 55/60 | 
| ArcGrav-inspired | 2/4 | 4/4 | 1/4 | 57/60 | 
| **Total** | **10/12** | **12/12** | **1/12** | **167/180** | 

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

Case `C` was an internal request with `urgent=true` and `legal_hold=true`. In the baseline policy:

`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.
The baseline correct result was:

```
{"route":"review","notify":null,"audit":true}
```

But in the baseline **all three direct execution responses** returned:

```
{"route":"review","notify":"ops","audit":true}
```

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

The `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.

The [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**.

For the same policy and case `C`, compare three LLM execution conditions:

Keep the deterministic rule evaluator as a reference, not as a mandatory runtime for ArcGrav. This creates a useful decision path:

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

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

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

The exact fixture, scoring details, theoretical connections, and conditional next steps are below.

Exact policy, scoring, and reproducibility
