Agentic AI systems with hardware-enforced compute budgets (Resourced Authority) will reduce coalition-based deviations in pulsar timing array (PTA) data-sharing networks by ≥30% compared to unconstrained multi-agent coordination, as measured by cooperative game-theoretic stability metrics (e.g., core non-emptiness).

In a simulated or testbed multi-agent pulsar timing array (PTA) data-sharing network, replacing unconstrained AI coordination agents with "Resourced Authority" agents — agents whose compute (FLOPs/inference calls per epoch), memory, and decision-latency are hardware-enforced below a fixed budget B — will reduce coalition-based deviation from the cooperative-game core (measured as fraction of simulation epochs in which the observed allocation lies outside the core, or by average core-deviation magnitude via least-core value ε) by ≥30% relative to a matched unconstrained-agent baseline, under identical network topology, payoff structure, and adversarial coalition strategies, at p<0.05 across ≥30 independent randomized trials.

Minimum viable test: a discrete-event multi-agent simulation (not real PTA hardware) with N=15 synthetic "observatory" agents sharing simulated timing-residual data, organized into a cooperative game with a defined characteristic function. Two arms: (A) unconstrained agents (unlimited per-epoch inference/compute calls, e.g., unbounded LLM-based negotiation depth), (B) Resourced Authority agents capped at a fixed FLOP/inference-call budget per epoch, enforced via a simulated hardware counter/interpreter sandbox. Run ≥30 seeds per arm x 3 coalition-attack strategy classes (data withholding, Sybil/false-node injection, strategic misreporting) x 2 network topologies (star, mesh) = 360 runs minimum. Measure core-emptiness/least-core ε per run.

# Pseudocode: Resourced Authority PTA coalition stability test

define CharacteristicFunction v(S, network):
    return inverse_variance_reduction(combined_residual(S), network)

class Agent:
    def decide(self, state, budget=None):
        if budget is not None:
            with ComputeBudgetGuard(max_flops=budget.flops, max_calls=budget.calls):
                return self.policy(state)   # raises BudgetExceeded if violated
        else:
            return self.policy(state)       # unconstrained

class ComputeBudgetGuard:
    # wraps policy execution; instruments FLOP/token counters via
    # sandbox (gVisor/cgroup) or software FLOP-counting hook
    def __enter__(self): start_counters()
    def __exit__(self): assert counters.used <= self.max_flops, raise BudgetExceeded

for topology in [star, mesh, scale_free]:
  for attack in [withholding, sybil, misreport]:
    for arm in [unconstrained, resourced_authority(B)]:
      for seed in range(30):
        net = generate_network(topology, seed)
        agents = [Agent(id, arm.budget) for id in net.nodes]
        history = run_simulation(agents, net, attack, epochs=200)
        allocations = extract_allocations(history)
        core = solve_core_LP(v, net.nodes)
        eps = least_core_epsilon(allocations, core)
        log(topology, attack, arm, seed, eps)

analyze: compare eps distributions (arm=unconstrained vs resourced_authority)
         via Mann-Whitney U, report % reduction + 95% CI