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): 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. The ArcGrav announcement 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 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