SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2409.10588 · ICML · 2025

ADIOS: Antibody Development via Opponent Shaping

Jakob Foerster, Aleksandra Kalisz, Sebastian Towers, Philippe Robert, Alicia Higueruelo, Francesca Vianello, Ming-Han Tsai, Harrison Steel, Starting Virus, Starting Antibody, Antibody Antibody

arXiv · PDF · Open in the Atlas

Code that ran

10 of 10 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 3 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 7 failures of our instrument; 0 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/2409.10588.json · badge: /api/ran/2409.10588.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
olakalisz/antibody-shapers canonical (classifier label)
classifier basis: census
7 ran · 0 no recorded run
olakalisz/adios canonical (classifier label)
classifier basis: classifier_2025
3 ran · 0 no recorded run
FunctionStatusWhere it lives
convert_aa_list Ran
ran, honoured the contract we drafted
olakalisz/antibody-shapers/src/adios/utils.py
code served (permissive licence) · get_code("8288e67e0842b158")
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 int, shape (2, 5) 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

# The function convert_aa_list takes a list of string sequences
# Each sequence is a string of amino acid characters
# The function converts each sequence to an integer array using the aminoacid_ids mapping

# Create a small list of valid amino acid sequences
list_sequences = [
    "CMFIL",  # 5 amino acids
    "VWYAG"   # 5 amino acids
]

ARGS = {
    "list_sequences": list_sequences
}
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 ArrayImpl, ndim 2, dtype family int, shape (2, 5) — shape (2, 5) 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
convert_aa_to_array Ran
ran, honoured the contract we drafted
olakalisz/antibody-shapers/src/adios/utils.py
code served (permissive licence) · get_code("cd53deb441215096")
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 1, dtype family int, shape (6,) 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

aminoacid_ids = {'C': 0, 'M': 1, 'F': 2, 'I': 3, 'L': 4, 'V': 5, 'W': 6, 'Y': 7, 'A': 8, 'G': 9, 'T': 10, 'S': 11, 'N': 12, 'Q': 13, 'D': 14, 'E': 15, 'R': 16, 'H': 17, 'K': 18, 'P': 19}

def convert_aa_to_array(sequence: str) -> jnp.ndarray:
    """
    Convert a string sequence to an int array.
    """
    return jnp.array([aminoacid_ids[aa] for aa in sequence], dtype=int)

# Create valid test sequence using amino acid characters
test_sequence = "CMFILV"

ARGS = {
    "sequence": test_sequence
}
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 ArrayImpl, ndim 1, dtype family int, shape (6,) — shape (6,) 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
convert_array_to_aa Ran
ran; our contract draft was wrong, not the code
olakalisz/antibody-shapers/src/adios/utils.py
code served (permissive licence) · get_code("2fa097b799dc5a94")
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 list, 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.numpy as jnp
import numpy as np

# The function expects a jax numpy array of amino acid IDs (integers)
# The IDs should correspond to values in the range 0-19 based on aminoacid_ids dict
amino_acid_array = jnp.array([0, 1, 2, 3, 8, 9, 10, 11], dtype=jnp.int32)

ARGS = {
    "amino_acid_ids": amino_acid_array
}
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 list, ndim 1, dtype family float — a list 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
decode_single_interaction Ran
ran, honoured the contract we drafted
olakalisz/antibody-shapers/src/adios/binding/interaction_matrix.py
code served (permissive licence) · get_code("7bacc512ad897dfa")
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 int; 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 torch
import numpy as np

ARGS = {
    "interaction_string": "a0000"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — 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 int — 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_binding_function Ran
ran; our contract draft was wrong, not the code
olakalisz/antibody-shapers/src/adios/binding/calculate_binding.py
code served (permissive licence) · get_code("26404b0a122f14c5")
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 function. 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 interaction matrix (padded protein interaction matrix)
# Typically 21x21 for amino acids (0-19) plus padding value (-1 maps to index 20)
jpadded_matrix = jnp.array(
    np.random.randn(21, 21),
    dtype=jnp.float32
)

# Define small site indices for primary and secondary binding sites
# These should be valid indices into the padded antibody/antigen sequences
primary_sites_antibody = jnp.array([0, 1], dtype=jnp.int32)  # 2 primary sites
secondary_sites_antibody = jnp.array([1, 2], dtype=jnp.int32)  # 2 secondary sites on antibody
secondary_sites_antigen = jnp.array([0, 2], dtype=jnp.int32)  # 2 secondary sites on antigen

# Create small antibody and antigen sequences
# Each is a batch of sequences with amino acid indices (0-19)
antibody = jnp.array([
    [5, 10, 3, 7],      # batch 1, length 4
    [12, 1, 8, 4]       # batch 2, length 4
], dtype=jnp.int32)

antigen = jnp.array([
    [2, 11, 6, 9],      # batch 1, length 4
    [14, 3, 7, 2]       # batch 2, length 4
], dtype=jnp.int32)

ARGS = {
    "primary_sites_antibody": primary_sites_antibody,
    "secondary_sites_antibody": secondary_sites_antibody,
    "secondary_sites_antigen": secondary_sites_antigen,
    "interaction_matrix": jpadded_matrix,
}
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 function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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_binding_function_extras Ran
ran; our contract draft was wrong, not the code
olakalisz/antibody-shapers/src/adios/binding/calculate_binding.py
code served (permissive licence) · get_code("d4688ada6aef3881")
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 function. 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 interaction matrix (21x21 for typical amino acid + padding)
# This will be used to look up binding interactions
interaction_matrix_data = np.random.randn(21, 21).astype(np.float32)
jpadded_matrix = jnp.array(interaction_matrix_data)

# Create small arrays for antibody and antigen binding sites
# These are indices into the sequences
primary_sites_antibody = jnp.array([0, 1, 2], dtype=jnp.int32)
secondary_sites_antibody = jnp.array([1, 2], dtype=jnp.int32)
secondary_sites_antigen = jnp.array([0, 1, 2], dtype=jnp.int32)

# Create a custom interaction matrix for this specific call
custom_interaction_matrix = jnp.array(np.random.randn(21, 21).astype(np.float32))

ARGS = {
    'primary_sites_antibody': primary_sites_antibody,
    'secondary_sites_antibody': secondary_sites_antibody,
    'secondary_sites_antigen': secondary_sites_antigen,
    'interaction_matrix': custom_interaction_matrix,
}
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 function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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_meta_shaping_iter Ran
ran; our contract draft was wrong, not the code
olakalisz/adios/src/adios/main_shaping_process.py
code served (permissive licence) · get_code("64b642e734473c7f")
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 function. 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 jax.random as jr

rng = jr.PRNGKey(0)
antibody_pop_size = 40

def mutation_function(rng_key, current_antibody, pop_size):
    """
    Mutation function that takes an rng, current antibody, and population size.
    Returns new_antibodies of shape (pop_size, *current_antibody.shape)
    """
    key = rng_key
    # Generate pop_size mutated versions of current_antibody
    noise = jr.normal(key, shape=(pop_size,) + current_antibody.shape)
    new_antibodies = current_antibody[None, :] + 0.1 * noise
    return new_antibodies

def eval_function(rng_key, antibodies):
    """
    Evaluation function that takes an rng and antibodies.
    Returns (eval_results, extra_information)
    eval_results should be shape (pop_size,) for argmin to work
    """
    pop_size = antibodies.shape[0]
    # Simple evaluation: sum of squares
    eval_results = jnp.sum(antibodies ** 2, axis=1)
    # Extra information can be any structure
    extra_information = {
        'mean_eval': jnp.mean(eval_results),
        'std_eval': jnp.std(eval_results)
    }
    return eval_results, extra_information

# Create initial antibody (small vector)
initial_antibody = jnp.array([1.0, 2.0, 3.0, 4.0])

ARGS = {
    'mutation_function': mutation_function,
    'eval_function': eval_function
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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_vmapped_bind_fs Ran
ran; our contract draft was wrong, not the code
olakalisz/antibody-shapers/src/adios/gen_alg_basic.py
code served (permissive licence) · get_code("5f4b119b32176dff")
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

def bind_extras(antigen, antibody):
    """
    A stand-in function that takes an antigen and antibody and returns a binding score.
    This mimics a binding energy calculation or similar biophysical function.
    """
    # Simple computation: sum and multiply to create a scalar output
    return jnp.sum(antigen) * jnp.sum(antibody)

# Create small test arrays for antigens and antibodies
# Using distinct shapes: antigens (2, 4), antibodies (3, 4)
antigen_batch = jnp.ones((2, 4))  # 2 antigens, 4 features each
antibody_batch = jnp.ones((3, 4))  # 3 antibodies, 4 features each

ARGS = {
    "bind_extras": bind_extras
}
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
mutate_onemut Ran
ran; our contract draft was wrong, not the code
olakalisz/adios/src/adios/main_shaping_process.py
code served (permissive licence) · get_code("b627beb5ef1d66d5")
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 ArrayImpl, ndim 2, dtype family int, shape (3, 7) 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
import jax.numpy as jnp
import jax.random as jr

# Create a PRNGKey for the rng parameter
rng = jr.PRNGKey(0)

# Create a small antibody sequence (shape: (7,) - representing 7 amino acid positions)
# Values should be in range [0, 19] representing amino acid indices
antibody = jnp.array([5, 10, 3, 15, 8, 2, 12], dtype=jnp.int32)

# Number of mutations to generate
reps = 3

ARGS = {
    "rng": rng,
    "antibody": antibody,
    "reps": reps
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
jax — 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 int, shape (3, 7) — shape (3, 7) 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
mutate_with_base Ran
ran; our contract draft was wrong, not the code
olakalisz/adios/src/adios/main_shaping_process.py
code served (permissive licence) · get_code("d7935e110ec8e5c2")
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 ArrayImpl, ndim 2, dtype family int, shape (3, 5) 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
import jax.numpy as jnp
import jax.random as jr

# Create a PRNG key
rng = jr.PRNGKey(0)

# Create a small antibody sequence
# The function expects a 1D array of integers (amino acid codes 0-19)
# Let's use shape (5,) for a small antibody sequence
antibody = jnp.array([1, 5, 3, 7, 2], dtype=jnp.int32)

# Number of repetitions
reps = 3

# Construct the ARGS dictionary
ARGS = {
    "rng": rng,
    "antibody": antibody,
    "reps": reps
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
jax — 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 int, shape (3, 5) — shape (3, 5) 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

Also present in other papers' code

Of 10 samples lifted from this paper's linked repositories, 10 carry a function identity and 0 do not. Of the 10 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 10 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.

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

Anti-viral therapies are typically designed to target only the current strains of a virus, a myopic response. However, therapy-induced selective pressures drive the emergence of new viral strains, against which the original myopic therapies are no longer effective. This evolutionary response presents an opportunity: our therapies could both defend against and actively influence viral evolution. This motivates our method ADIOS: Antibody Development vIa Opponent Shaping. ADIOS is a meta-learning framework where the process of antibody therapy design, the outer loop, accounts for the virus's adaptive response, the inner loop. With ADIOS, antibodies are not only robust against potential future variants, they also influence, i.e., shape, which future variants emerge. In line with the opponent shaping literature, we refer to our optimised antibodies as shapers. To demonstrate the value of ADIOS, we build a viral evolution simulator using the Absolut! framework, in which shapers successfully target both current and future viral variants, outperforming myopic antibodies. Furthermore, we show that shapers modify the distribution over viral evolutionary trajectories to result in weaker variants. We believe that our ADIOS paradigm will facilitate the discovery of long-lived vaccines and antibody therapies while also generalising to other domains. Specifically, domains such as antimicrobial resistance, cancer treatment, and others with evolutionarily adaptive opponents. Our code is available at https: //github.com/olakalisz/adios.

For agents

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

get_harvested_code_for_paper("2409.10588")
get_code_for_paper("2409.10588")
have("2409.10588")

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

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

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

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

Connect an agent — have() is free.