agentic-behavioral-modeling

name	agentic-behavioral-modeling
description	Agentic Behavioral Modeling (ABM) framework integrating theoretical neuroscience, decision theory, and probabilistic inference. Treats AI agents as latent generative hypotheses about cognitive mechanisms for explaining human behavior. Activation triggers: agentic modeling, behavioral modeling, cognitive agents, decision theory, Rescorla-Wagner learning, Bayesian inference.

Agentic Behavioral Modeling Framework

A framework for treating artificial agents as latent, generative hypotheses about cognitive mechanisms and evaluating them by statistical adequacy in explaining human behavior.

Metadata

• Source: arXiv:2604.27894
• Authors: Dirk Ostwald, Rasmus Bruckner, Franziska Usée, Belinda Fleischmann, Joram Soch, Sean Mulready
• Published: 2026-04-30
• Category: Neurons and Cognition (q-bio.NC)

Core Methodology

Key Innovation

ABM bridges agentic AI models and behavioral data analysis by formalizing task-agent-data systems as joint probability models. This enables rigorous model comparison through explicit conditional log-likelihoods and statistical validation.

Theoretical Foundation

Three Pillars:

1. Theoretical Neuroscience: Mechanistic accounts of neural computation
2. Decision Theory: Normative frameworks for optimal choice
3. Probabilistic Inference: Statistical methods for model evaluation

Core Principle:

Artificial Agent → Latent Cognitive Hypothesis
       ↓
Generative Model of Behavior
       ↓
Statistical Evaluation via Likelihood

Formal Framework

Joint Probability Model

p(a, d | θ, m) = p(a | d, θ, m) * p(d | θ, m)

Where:

• a: Agent parameters
• d: Behavioral data
• θ: Model parameters
• m: Model structure

Conditional Log-Likelihood

log L(θ | d, m) = Σ_i log p(d_i | θ, m)

Implementation Examples

Example 1: Perceptual Contrast Discrimination

Task: Binary perceptual decision

Agent Model: Signal Detection Theory (SDT) Agent

class SDTAgent:
    def __init__(self, d_prime, criterion):
        self.d_prime = d_prime  # Sensitivity
        self.criterion = criterion  # Response bias
    
    def decision(self, stimulus_contrast):
        # Internal signal with noise
        signal = stimulus_contrast + np.random.normal(0, 1)
        # Decision rule
        return 1 if signal > self.criterion else 0
    
    def choice_probability(self, contrast):
        """Psychometric function."""
        from scipy.stats import norm
        return 1 - norm.cdf(self.criterion - self.d_prime * contrast)

Agent-Centric Psychometric Function:

P(choose_high | contrast c) = Φ(d' * c - λ)

Where Φ is the standard normal CDF, d' is sensitivity, and λ is the criterion.

Example 2: Two-Armed Bandit Learning

Task: Sequential reward maximization

Agent Models:

1. Rescorla-Wagner (RW) Learning:

class RescorlaWagnerAgent:
    def __init__(self, alpha, beta, n_arms=2):
        self.alpha = alpha  # Learning rate
        self.beta = beta    # Inverse temperature
        self.Q = np.zeros(n_arms)  # Action values
        
    def choose_action(self):
        # Softmax choice
        probs = np.exp(self.beta * self.Q)
        probs /= probs.sum()
        return np.random.choice(len(self.Q), p=probs)
    
    def update(self, action, reward):
        # Prediction error
        prediction_error = reward - self.Q[action]
        # Value update
        self.Q[action] += self.alpha * prediction_error
        return prediction_error

2. Bayesian Optimal Agent:

class BayesianBanditAgent:
    def __init__(self, n_arms=2):
        # Prior: Beta(1, 1) for each arm
        self.alpha = np.ones(n_arms)
        self.beta = np.ones(n_arms)
        
    def choose_action(self):
        # Thompson sampling
        samples = [np.random.beta(self.alpha[i], self.beta[i]) 
                   for i in range(len(self.alpha))]
        return np.argmax(samples)
    
    def update(self, action, reward):
        # Bayesian update
        self.alpha[action] += reward
        self.beta[action] += (1 - reward)

Key Result: RW learning is equivalent to Bayesian inference in symmetric bandits under specific parameterizations.

Model Recovery Validation

Parameter Recovery

def parameter_recovery(agent_class, true_params, n_trials=1000):
    """
    Validate that model parameters can be recovered from simulated data.
    """
    # Generate synthetic data with known parameters
    agent = agent_class(**true_params)
    data = simulate_behavior(agent, n_trials)
    
    # Fit model to synthetic data
    fitted_params = fit_model(agent_class, data)
    
    # Compare true vs. fitted
    return {k: (true_params[k], fitted_params[k]) 
            for k in true_params.keys()}

Model Recovery

def model_comparison(models, data):
    """
    Compare multiple agent models using information criteria.
    """
    results = {}
    for name, model_class in models.items():
        # Fit model
        fitted = fit_model(model_class, data)
        log_likelihood = fitted.log_likelihood
        n_params = len(fitted.params)
        
        # AIC
        aic = -2 * log_likelihood + 2 * n_params
        
        # BIC
        bic = -2 * log_likelihood + n_params * np.log(len(data))
        
        results[name] = {
            'log_likelihood': log_likelihood,
            'AIC': aic,
            'BIC': bic
        }
    
    return results

Applications

Cognitive Science

• Formal testing of cognitive theories
• Model-based analysis of decision-making
• Bridging computational and algorithmic levels

Neuroscience

• Linking neural activity to computational models
• Understanding neural basis of decision-making
• Model-based fMRI/EEG analysis

AI/Human-AI Interaction

• Evaluating AI agents against human behavior
• Designing human-like AI systems
• Understanding human-AI collaboration

Clinical Psychology

• Computational phenotyping
• Psychiatric diagnosis support
• Treatment outcome prediction

Pitfalls

Model Selection

1. Overfitting: Complex agents may fit noise
2. Identifiability: Different parameters may produce similar behavior
3. Model Misspecification: True process not in model space

Inference Challenges

1. Local Minima: Non-convex optimization landscapes
2. Parameter Correlations: Dependencies between parameters
3. Individual Differences: Group vs. individual-level inference

Implementation Issues

1. Numerical Stability: Log-probability computations
2. Convergence: MCMC or optimization convergence
3. Validation: Need independent test data

Related Skills

• reinforcement-learning-models
• bayesian-cognitive-modeling
• decision-theory-neuroscience
• model-based-fmri
• computational-psychiatry

References

Primary Source

• Ostwald, D., et al. (2026). On Agentic Behavioral Modeling. arXiv:2604.27894 [q-bio.NC].

Key Background

• Rescorla, R. A., & Wagner, A. R. (1972). A theory of Pavlovian conditioning.
• Sutton, R. S., & Barto, A. G. (2018). Reinforcement learning: An introduction.
• Daw, N. D. (2011). Trial-by-trial data analysis using computational models.

Implementation Workflow

Step 1: Define Task Structure

task_spec = {
    'actions': ['left', 'right'],
    'observations': ['stimulus_left', 'stimulus_right'],
    'rewards': [0, 1],
    'trials': 100
}

Step 2: Implement Agent

class CustomAgent:
    def __init__(self, params):
        self.params = params
        
    def act(self, observation, history):
        # Compute action probabilities
        return action_probs
    
    def update(self, observation, action, reward):
        # Update internal state
        pass

Step 3: Fit to Data

from scipy.optimize import minimize

def negative_log_likelihood(params, agent_class, data):
    agent = agent_class(**params)
    nll = 0
    for trial in data:
        action_probs = agent.act(trial['obs'], trial['history'])
        nll -= np.log(action_probs[trial['action']])
        agent.update(trial['obs'], trial['action'], trial['reward'])
    return nll

result = minimize(negative_log_likelihood, 
                  x0=initial_params,
                  args=(CustomAgent, data))

Step 4: Validate Model

# Parameter recovery
recovery_results = parameter_recovery(CustomAgent, true_params)

# Model comparison
comparison = model_comparison({
    'CustomAgent': CustomAgent,
    'Baseline': RandomAgent
}, data)

Keywords

agentic behavioral modeling, cognitive agents, decision theory, Rescorla-Wagner, Bayesian inference, psychometric function, reinforcement learning, model recovery, parameter estimation, computational cognitive science