SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2412.04233 · NeurIPS · 2025

HyperMARL: Adaptive Hypernetworks for Multi-Agent RL

Amos Storkey, Stefano Albrecht, Arrasy Rahman, Kale-Ab Abebe, Encoder, Grads Obs, Grads

arXiv · PDF · Open in the Atlas

Code that ran

11 of 26 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (1 of them constructed an object rather than computing a result; 2 honoured the contract we drafted, 0 violated it and 1 has no contract verdict; 8 failures of our instrument; 15 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2412.04233.json · badge: /api/ran/2412.04233.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
KaleabTessera/HyperMARL canonical (classifier label)
classifier basis: census
9 ran · 12 no recorded run
kaleabtessera/hypermarl canonical (classifier label)
classifier basis: classifier_2025
2 ran · 3 no recorded run
FunctionStatusWhere it lives
MLPHyperNetwork Ran
ran on a synthesized input · constructed an object; no result was computed
kaleabtessera/hypermarl/baselines/IPPO/ippo_ff_shared_weights_mlp_hypernets.py
code served (permissive licence) · get_code("1752721940e08b00")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, MLPHyperNetwork: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
import flax.linen as nn
import numpy as np
from enum import Enum
from typing import List, Tuple

class HyperNetType(Enum):
    """Types of hypernetworks for different parts of the policy."""
    ACTOR = 0
    CRITIC = 1

# Create small test inputs
batch_size = 2
embedding_dim = 4

# Define output dimensions for target network layers
# Using distinct sizes: (input_dim, output_dim)
output_dims = [
    (4, 8),   # First layer: 4 -> 8
    (8, 6),   # Second layer: 8 -> 6
]

ARGS = {
    "output_dims": output_dims,
    "hypernet_type": HyperNetType.ACTOR,
    "init_scale": np.sqrt(2),
    "use_bias": True,
    "hidden_dims": (64,),
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MLPHyperNetwork — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MLPHyperNetwork output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
batchify Ran
ran, honoured the contract we drafted
KaleabTessera/HyperMARL/baselines/MAPPO/mappo_rnn_smax_mlp_hypernets_eval.py
code served (permissive licence) · get_code("3425052e6f822468")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp
import numpy as np

# Create agent observations
agent_ids = ["agent_0", "agent_1"]
num_agents = len(agent_ids)
num_actors = 2
observation_dim = 4

# Create a dictionary mapping agent IDs to observations
# Each observation is a small JAX array
x = {
    "agent_0": jnp.array([1.0, 2.0, 3.0, 4.0]),
    "agent_1": jnp.array([5.0, 6.0, 7.0, 8.0])
}

# Create the agent list
agent_list = agent_ids

# Define ARGS
ARGS = {
    "x": x,
    "agent_list": agent_list,
    "num_actors": num_actors
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
calculate_gradient_metrics Ran
ran, honoured the contract we drafted
KaleabTessera/HyperMARL/baselines/IPPO/ppo.py
code served (permissive licence) · get_code("cef5d3f8f582f11c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp

# Create a sample gradient structure - can be a nested dict/tuple of arrays
# The function uses jax.tree_util.tree_leaves to flatten it
grads = {
    'layer1': jnp.array([[0.1, 0.2, 0.3, 0.4],
                         [0.5, 0.6, 0.7, 0.8]]),
    'layer2': jnp.array([0.9, 1.0, 1.1, 1.2]),
    'layer3': jnp.array([[0.05, 0.15],
                         [0.25, 0.35],
                         [0.45, 0.55],
                         [0.65, 0.75]])
}

ARGS = {
    'grads': grads
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_update_fn_ff_ppo Ran
ran; our contract draft was wrong, not the code
KaleabTessera/HyperMARL/baselines/IPPO/ppo.py
code served (permissive licence) · get_code("5acb214ca13472b6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned PjitFunction. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
import distrax
from typing import NamedTuple

# Define trajectory batch structure
class Transition(NamedTuple):
    obs: jnp.ndarray
    action: jnp.ndarray
    reward: jnp.ndarray
    done: jnp.ndarray
    value: jnp.ndarray
    log_prob: jnp.ndarray

# Create a simple feedforward network
class SimpleFFNetwork:
    def apply(self, params, obs, training=False):
        """
        Apply network to observations.
        Returns (actor_output, value) for discrete action space.
        """
        # For discrete action space: logits for actions
        actor_output = jnp.ones((obs.shape[0], 4))  # 4 discrete actions
        # Value estimate
        value = jnp.mean(obs, axis=1, keepdims=True)
        return (actor_output, value)

# Create config dictionary
config = {
    'GAMMA': 0.99,
    'GAE_LAMBDA': 0.95,
    'CLIP_EPS': 0.2,
    'VF_COEF': 0.5,
    'ENT_COEF': 0.01,
    'ACTION_SPACE_TYPE': 'discrete',
}

# Create network instance
network = SimpleFFNetwork()

# Create trajectory batch with small dimensions
batch_size = 2
obs_dim = 4
action_dim = 4
seq_length = 3

traj_batch = Transition(
    obs=jnp.ones((seq_length, batch_size, obs_dim)),
    action=jnp.array([[0, 1], [1, 2], [0, 1]]),  # shape (seq_length, batch_size)
    reward=jnp.ones((seq_length, batch_size)),
    done=jnp.zeros((seq_length, batch_size)),
    value=jnp.ones((seq_length, batch_size, 1)),
    log_prob=jnp.ones((seq_length, batch_size)),
)

# Create last observations
last_obs = jnp.ones((batch_size, obs_dim))

# Create simple train state
class TrainState(NamedTuple):
    params: dict

train_state = TrainState(
    params={'w1': jnp.ones((obs_dim, 8)), 'w2': jnp.ones((8, action_dim + 1))},
)

# Create RNG key
rng = jax.random.PRNGKey(0)

ARGS = {
    'config': config,
    'network': network,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
distrax, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type PjitFunction — a PjitFunction output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PjitFunction output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_update_fn_rec Ran
ran; our contract draft was wrong, not the code
KaleabTessera/HyperMARL/baselines/IPPO/ppo.py
code served (permissive licence) · get_code("713c47ef2b9b7452")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned PjitFunction. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
import numpy as np
from flax import linen as nn
from flax.training import train_state
import optax

# Define a minimal recurrent network that matches the function's usage
class RecurrentNetwork(nn.Module):
    hidden_size: int = 4
    action_dim: int = 3
    
    @nn.compact
    def __call__(self, hstate, ac_in):
        obs, done = ac_in
        # Simulate RNN processing
        x = nn.Dense(self.hidden_size)(obs)
        # Return: new_hstate, policy_distribution, value
        # For policy, we need something with log_prob and entropy methods
        # For simplicity, return dummy arrays that match expected shapes
        new_hstate = x
        # Return a mock policy (we'll use a simple distribution-like object)
        policy = jnp.ones((obs.shape[0], self.action_dim))
        value = jnp.mean(x, axis=-1, keepdims=True)
        return new_hstate, policy, value

# Create a wrapper to make the network compatible with JAX operations
class PolicyDistribution:
    def __init__(self, logits):
        self.logits = logits
    
    def log_prob(self, actions):
        # Simple mock log_prob
        return -jnp.abs(actions).mean(axis=-1)
    
    def entropy(self):
        # Simple mock entropy
        return jnp.ones(self.logits.shape[0])

# Wrap network to return proper distribution
class WrappedRecurrentNetwork(nn.Module):
    hidden_size: int = 4
    action_dim: int = 3
    
    @nn.compact
    def __call__(self, hstate, ac_in):
        obs, done = ac_in
        x = nn.Dense(self.hidden_size)(obs)
        new_hstate = x
        policy_logits = nn.Dense(self.action_dim)(x)
        value = nn.Dense(1)(x)
        return new_hstate, policy_logits, value.squeeze(-1)

# Define trajectory batch structure
class TrajectoryBatch:
    def __init__(self, batch_size, seq_len, obs_dim, action_dim):
        self.obs = jnp.ones((seq_len, batch_size, obs_dim))
        self.action = jnp.ones((seq_len, batch_size), dtype=jnp.int32)
        self.done = jnp.zeros((seq_len, batch_size))
        self.value = jnp.ones((seq_len, batch_size))
        self.reward = jnp.ones((seq_len, batch_size))
        self.log_prob = jnp.ones((seq_len, batch_size))
        self.global_done = jnp.zeros((seq_len, batch_size))

# Configuration dictionary
config = {
    'GAMMA': 0.99,
    'GAE_LAMBDA': 0.95,
    'CLIP_EPS': 0.2,
    'VF_COEF': 0.5,
    'ENT_COEF': 0.01,
    'NUM_EPOCHS': 4,
    'NUM_MINBATCHES': 4,
}

# Initialize network
network = WrappedRecurrentNetwork(hidden_size=4, action_dim=3)
hidden_state_size = 4

# Create dummy parameters and training state
key = jax.random.PRNGKey(0)
batch_size = 2
obs_dim = 4
seq_len = 5

# Initialize parameters
dummy_obs = jnp.ones((1, batch_size, obs_dim))
dummy_done = jnp.zeros((1, batch_size))
dummy_hstate = jnp.ones((batch_size, hidden_state_size))

params = network.init(key, dummy_hstate, (dummy_obs, dummy_done))

# Create training state
optimizer = optax.adam(learning_rate=1e-3)
ts = train_state.TrainState.create(
    apply_fn=network.apply,
    params=params,
    tx=optimizer
)

# Build arguments
ARGS = {
    'config': config,
    'network': network,
    'hidden_state_size': hidden_state_size,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax, numpy, optax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type PjitFunction — a PjitFunction output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PjitFunction output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
initialize_metrics_storage Ran
ran; our contract draft was wrong, not the code
kaleabtessera/hypermarl/baselines/IPPO/ippo_ff_shared_weights_mlp_hypernets.py
code served (permissive licence) · get_code("c65ecc507b666ec7")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create a configuration dictionary with NUM_UPDATES defined
config = {
    'NUM_UPDATES': 100
}

# Create a list of metric keys to track
metric_keys = ['loss', 'accuracy', 'f1_score', 'precision']

# Define ARGS mapping all parameters
ARGS = {
    'config': config,
    'metric_keys': metric_keys
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
initialize_metrics_storage Ran
ran; our contract draft was wrong, not the code
KaleabTessera/HyperMARL/baselines/MAPPO/mappo_ff_shared_weights_linear_hypernets.py
code served (permissive licence) · get_code("ddd7b106ce20543f")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

config = {
    'NUM_UPDATES': 100
}

metric_keys = ['loss', 'accuracy', 'validation_loss']

ARGS = {
    'config': config,
    'metric_keys': metric_keys
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
initialize_metrics_storage Ran
ran; our contract draft was wrong, not the code
KaleabTessera/HyperMARL/baselines/IPPO/ippo_ff_nps.py
code served (permissive licence) · get_code("f751066367a6eef7")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Define the arguments for initialize_metrics_storage
config = {
    'NUM_UPDATES': 100
}

metric_keys = [
    'loss',
    'accuracy',
    'validation_loss',
    'f1_score'
]

ARGS = {
    'config': config,
    'metric_keys': metric_keys
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
initialize_metrics_storage Ran
ran; our contract draft was wrong, not the code
KaleabTessera/HyperMARL/baselines/IPPO/ippo_ff_shared_weights.py
code served (permissive licence) · get_code("56878577396cbd05")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
from typing import Dict, List

# Set random seed for reproducibility
np.random.seed(0)

# Construct config dictionary with NUM_UPDATES key
config = {
    'NUM_UPDATES': 100,
    'LEARNING_RATE': 0.001,
    'BATCH_SIZE': 32
}

# Construct list of metric keys to track
metric_keys = [
    'loss',
    'accuracy',
    'validation_loss',
    'f1_score'
]

# Map all parameters to their values
ARGS = {
    'config': config,
    'metric_keys': metric_keys
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
unbatchify Ran
ran; our contract draft was wrong, not the code
KaleabTessera/HyperMARL/baselines/IPPO/ippo_rnn_smax_mlp_hypernets_eval.py
code served (permissive licence) · get_code("6febd2e7a2d28568")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp
import numpy as np

# Set random seed for reproducibility
np.random.seed(0)

# Define parameters for unbatchify function
num_envs = 2
num_actors = 3
agent_list = ['agent_0', 'agent_1', 'agent_2']

# Create a batched array with shape (num_actors * num_envs, feature_dim)
# This will be reshaped to (num_actors, num_envs, feature_dim)
feature_dim = 4
batched_array = jnp.arange(num_actors * num_envs * feature_dim, dtype=jnp.float32).reshape((num_actors * num_envs, feature_dim))

ARGS = {
    'x': batched_array,
    'agent_list': agent_list,
    'num_envs': num_envs,
    'num_actors': num_actors
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
unbatchify Ran
ran; our contract draft was wrong, not the code
KaleabTessera/HyperMARL/baselines/MAPPO/mappo_rnn_smax_mlp_hypernets_eval.py
code served (permissive licence) · get_code("3e5d2a25923e7af8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp
import numpy as np

# Create a small batched array
# Shape: (num_actors, num_envs * feature_dim)
# Let's say num_actors=3, num_envs=2, feature_dim=4
num_actors = 3
num_envs = 2
feature_dim = 4

# Create a batched array of shape (3, 8) which will reshape to (3, 2, 4)
x = jnp.arange(num_actors * num_envs * feature_dim, dtype=jnp.float32).reshape(num_actors, num_envs * feature_dim)

# Create agent list with 3 agent IDs
agent_list = ["agent_0", "agent_1", "agent_2"]

ARGS = {
    "x": x,
    "agent_list": agent_list,
    "num_envs": num_envs,
    "num_actors": num_actors,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
HyperNetType Not yet run
unverified (harvested, no recorded run)
kaleabtessera/hypermarl/baselines/IPPO/ippo_ff_shared_weights_mlp_hypernets.py
code served (permissive licence) · get_code("fc2635d1edc5744c")
How it ran

no invocation recorded.

batchify Not yet run
unverified (harvested, no recorded run)
KaleabTessera/HyperMARL/baselines/IPPO/ippo_rnn_smax_mlp_hypernets_eval.py
code served (permissive licence) · get_code("199a93e72a7ef243")
How it ran

no invocation recorded.

check_rows_orthogonal Not yet run
unverified (harvested, no recorded run)
kaleabtessera/hypermarl/baselines/IPPO/ippo_ff_shared_weights_mlp_hypernets.py
code served (permissive licence) · get_code("bcb0454a347fa497")
How it ran

no invocation recorded.

check_rows_orthogonal Not yet run
unverified (harvested, no recorded run)
KaleabTessera/HyperMARL/baselines/Matrix_Game/specialisation_game_with_state_jax_hypermarl_base.py
code served (permissive licence) · get_code("81333b03547dec15")
How it ran

no invocation recorded.

check_rows_orthogonal Not yet run
unverified (harvested, no recorded run)
KaleabTessera/HyperMARL/baselines/IPPO/ippo_ff_shared_weights_linear_hypernets.py
code served (permissive licence) · get_code("39a086f00e865a15")
How it ran

no invocation recorded.

check_rows_orthogonal Not yet run
unverified (harvested, no recorded run)
KaleabTessera/HyperMARL/baselines/IPPO/ippo_rnn_smax_mlp_hypernets_eval.py
code served (permissive licence) · get_code("74c4e3ca9e6165a8")
How it ran

no invocation recorded.

check_rows_orthogonal Not yet run
unverified (harvested, no recorded run)
KaleabTessera/HyperMARL/baselines/MAPPO/mappo_ff_shared_weights_linear_hypernets.py
code served (permissive licence) · get_code("33389a53f0258aa8")
How it ran

no invocation recorded.

initialize_metrics_storage Not yet run
unverified (harvested, no recorded run)
KaleabTessera/HyperMARL/baselines/IPPO/ippo_ff_shared_weights_linear_hypernets.py
code served (permissive licence) · get_code("9448f3eb55de759e")
How it ran

no invocation recorded.

make Not yet run
unverified (harvested, no recorded run)
KaleabTessera/HyperMARL/jaxmarl/registration.py
code served (permissive licence) · get_code("e322b3637217c7eb")
How it ran

no invocation recorded.

play_episode Not yet run
unverified (harvested, no recorded run)
KaleabTessera/HyperMARL/baselines/Matrix_Game/specialisation_game_with_state_jax_hypermarl_base.py
code served (permissive licence) · get_code("3ca3980ead7240ce")
How it ran

no invocation recorded.

update_metrics Not yet run
unverified (harvested, no recorded run)
kaleabtessera/hypermarl/baselines/IPPO/ippo_ff_shared_weights_mlp_hypernets.py
code served (permissive licence) · get_code("3b65097bdfeabc03")
How it ran

no invocation recorded.

update_metrics Not yet run
unverified (harvested, no recorded run)
KaleabTessera/HyperMARL/baselines/IPPO/ippo_ff_shared_weights_linear_hypernets.py
code served (permissive licence) · get_code("1ebe26893033a16f")
How it ran

no invocation recorded.

update_metrics Not yet run
unverified (harvested, no recorded run)
KaleabTessera/HyperMARL/baselines/MAPPO/mappo_ff_shared_weights_linear_hypernets.py
code served (permissive licence) · get_code("34e77efd01e92918")
How it ran

no invocation recorded.

update_metrics Not yet run
unverified (harvested, no recorded run)
KaleabTessera/HyperMARL/baselines/IPPO/ippo_ff_nps.py
code served (permissive licence) · get_code("e1710023a6660530")
How it ran

no invocation recorded.

update_metrics Not yet run
unverified (harvested, no recorded run)
KaleabTessera/HyperMARL/baselines/IPPO/ippo_ff_shared_weights.py
code served (permissive licence) · get_code("6891de2d310cbd35")
How it ran

no invocation recorded.

Also present in other papers' code

Of 26 samples lifted from this paper's linked repositories, 26 carry a function identity and 0 do not. Of the 15 distinct functions with an identity, 2 are also present in other papers whose code we hold (2 with at least one paper dated earlier, 0 the same month, 0 later) and 13 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
batchify 1 other paper
1 dated earlier
2408.15099 (2024-08)
No Regrets: Investigating and Improving Regret Approximations for Curriculum Discovery
unbatchify 1 other paper
1 dated earlier
2408.15099 (2024-08)
No Regrets: Investigating and Improving Regret Approximations for Curriculum Discovery

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Adaptive cooperation in multi-agent reinforcement learning (MARL) requires policies to express homogeneous, specialised, or mixed behaviours, yet achieving this adaptivity remains a critical challenge. While parameter sharing (PS) is standard for efficient learning, it notoriously suppresses the behavioural diversity required for specialisation. This failure is largely due to cross-agent gradient interference, a problem we find is surprisingly exacerbated by the common practice of coupling agent IDs with observations. Existing remedies typically add complexity through altered objectives, manual preset diversity levels, or sequential updates -raising a fundamental question: can shared policies adapt without these intricacies? We propose a solution built on a key insight: an agent-conditioned hypernetwork can generate agent-specific parameters and decouple observationand agent-conditioned gradients, directly countering the interference from coupling agent IDs with observations. Our resulting method, HyperMARL, avoids the complexities of prior work and empirically reduces policy gradient variance. Across diverse MARL benchmarks (22 scenarios, up to 30 agents), HyperMARL achieves performance competitive with six key baselines while preserving behavioural diversity comparable to non-parameter sharing methods, establishing it as a versatile and principled approach for adaptive MARL. The code is publicly available at https://github.com/KaleabTessera/HyperMARL.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2412.04233")
get_code_for_paper("2412.04233")
have("2412.04233")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2412.04233.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2412.04233.svg)](https://syntology.ai/paper/2412.04233)

Connect an agent — have() is free.