negmas.registry

NegMAS Registry System for Mechanisms, Negotiators, Components, and Scenarios.

Overview

The registry system provides a centralized way to register, discover, and query negotiation-related classes and scenarios. It enables:

1. Discovery: Find all available implementations without knowing their locations

2. Querying: Filter implementations by properties (e.g., find all ANAC negotiators)

3. Extensibility: External libraries can register their own implementations

4. Metadata: Store and retrieve information about each implementation

Architecture

The registry consists of four separate registries, each for a different type:

• mechanism_registry: Negotiation mechanisms (e.g., SAOMechanism, TAUMechanism)

• negotiator_registry: Negotiation agents (e.g., AspirationNegotiator, NaiveTitForTatNegotiator)

• component_registry: BOA components (acceptance strategies, offering strategies, opponent models)

• scenario_registry: Negotiation scenarios (domain + utility function definitions)

Key Design: Registry Keys

For class registries (mechanisms, negotiators, components), keys work as follows:

• Primary key: short_name - A human-readable name (e.g., “AspirationNegotiator”)

• Fallback key: full_type_name - Fully qualified name (e.g., “negmas.sao.AspirationNegotiator”)

When registering a class:

1. If no short_name is provided, the class name (cls.__name__) is used

2. If the short_name already exists for a different class, the new class is registered under its full_type_name instead (to avoid silent overwrites)

3. Both names can be used to retrieve the class via get_class()

This design provides:

• Convenience: Use short names like “SAOMechanism” for common lookups

• Safety: No silent overwrites when names clash (e.g., two libraries both defining “MyNegotiator”)

• Uniqueness: The full_type_name is always unique and can be used when short names are ambiguous

For scenario registries, keys are the resolved absolute path (always unique).

Usage Examples

Registering Classes

Using decorators (recommended):

from negmas import register_negotiator, register_mechanism

@register_negotiator(
    bilateral_only=True,
    learns=True,
    tags={"custom", "learning"},
)
class MyLearningNegotiator(SAONegotiator):
    '''A custom negotiator that learns.'''
    pass

@register_mechanism(requires_deadline=False, tags={"custom"})
class MyMechanism(Mechanism):
    pass

Using direct registration:

from negmas import negotiator_registry, NegotiatorInfo

class AnotherNegotiator(SAONegotiator):
    pass

negotiator_registry.register(
    AnotherNegotiator,
    short_name="another",  # Optional custom name
    tags={"experimental"},
)

Discovering and Querying

List all registered items:

from negmas import negotiator_registry, mechanism_registry

# List all negotiators
for name, info in negotiator_registry.items():
    print(f"{name}: {info.full_type_name}")

# List just the names
print(list(negotiator_registry.keys()))

Query by properties:

# Find negotiators that learn
learners = negotiator_registry.query(learns=True)

# Find ANAC 2019 negotiators
anac2019 = negotiator_registry.query(anac_year=2019)

# Find mechanisms that don't require a deadline
flexible = mechanism_registry.query(requires_deadline=False)

Query by tags:

# Find items with ALL specified tags
builtin_sao = negotiator_registry.query(tags=["builtin", "sao"])

# Find items with ANY of the specified tags
genius_or_builtin = negotiator_registry.query(any_tags=["genius", "builtin"])

# Exclude items with certain tags
no_genius = negotiator_registry.query(exclude_tags=["genius"])

# Combined tag filtering
results = negotiator_registry.query(
    tags=["sao"],  # Must have "sao"
    any_tags=["anac-2018", "anac-2019"],  # Must have one of these
    exclude_tags=["experimental"],  # Must not have this
)

Get a specific class:

from negmas import negotiator_registry

# By short name
cls = negotiator_registry.get_class("AspirationNegotiator")

# By full type name (useful when short names clash)
cls = negotiator_registry.get_class("negmas.sao.negotiators.AspirationNegotiator")

Working with Scenarios

Register individual scenarios:

from negmas import register_scenario

info = register_scenario(
    "/path/to/my/scenario",
    name="MyScenario",
    tags={"custom", "bilateral"},
    n_negotiators=2,
)

Register all scenarios from a directory:

from negmas import register_all_scenarios

# Recursively find and register all loadable scenarios
scenarios = register_all_scenarios(
    "/path/to/scenarios",
    tags={"my-project"},
)
print(f"Registered {len(scenarios)} scenarios")

Query scenarios:

from negmas import scenario_registry

# Find bilateral scenarios
bilateral = scenario_registry.query(tags=["bilateral"])

# Find XML format scenarios
xml_scenarios = scenario_registry.query(format="xml")

# Get scenario by name (may return multiple if name is not unique)
camera_scenarios = scenario_registry.get_by_name("CameraB")

Built-in Registrations

NegMAS automatically registers:

• Built-in mechanisms (SAOMechanism, TAUMechanism, etc.)

• Built-in negotiators (AspirationNegotiator, NaiveTitForTatNegotiator, etc.)

• Genius negotiators (imported from Genius library)

• BOA components (acceptance, offering, opponent modeling strategies)

• Built-in scenarios (CameraB, etc.)

These are registered when you import from negmas and can be discovered immediately:

from negmas import negotiator_registry

# See all registered negotiators
print(f"Total negotiators: {len(negotiator_registry)}")

# Filter by source
builtin = negotiator_registry.query(tags=["builtin"])
genius = negotiator_registry.query(tags=["genius"])
print(f"Built-in: {len(builtin)}, Genius: {len(genius)}")

CLI Access

The registry is also accessible via the command line:

# List all mechanisms
negmas registry list mechanisms

# List negotiators with filters
negmas registry list negotiators --tag genius --tag anac-2019

# Show registry statistics
negmas registry stats

# Search by name pattern
negmas registry search "Aspiration*"

# List all tags
negmas registry tags --count

class negmas.registry.ComponentInfo(key: str, short_name: str, full_type_name: str, cls: type, source: str = 'unknown', description: str = '', params: dict[str, ~typing.Any]=<factory>, tags: set[str] = <factory>, extra: dict[str, ~typing.Any]=<factory>, component_type: str = 'generic')

Bases: RegistryInfo

Registration information for components.

component_type

The type of component (e.g., ‘acceptance’, ‘offering’, ‘model’).

Type:

str

component_type: str = 'generic'

class negmas.registry.MechanismInfo(key: str, short_name: str, full_type_name: str, cls: type, source: str = 'unknown', description: str = '', params: dict[str, ~typing.Any]=<factory>, tags: set[str] = <factory>, extra: dict[str, ~typing.Any]=<factory>)

Bases: RegistryInfo

Registration information for mechanisms.

All mechanism properties are now expressed via tags: - “requires-deadline”: Mechanism requires n_steps or time_limit - “propose”: Requires negotiators to have propose capability - “respond”: Requires negotiators to have respond capability - “sao”, “gb”, “tau”, “st”: Protocol type tags

class negmas.registry.NegotiatorInfo(key: str, short_name: str, full_type_name: str, cls: type, source: str = 'unknown', description: str = '', params: dict[str, ~typing.Any]=<factory>, tags: set[str] = <factory>, extra: dict[str, ~typing.Any]=<factory>)

Bases: RegistryInfo

Registration information for negotiators.

All negotiator properties are now expressed via tags: - “bilateral-only”: Only works in bilateral negotiations - “requires-opponent-ufun”: Requires access to opponent’s utility function - “learning”: Learns from repeated negotiations - “anac-YYYY”: ANAC competition year (e.g., “anac-2019”) - “supports-uncertainty”: Supports uncertain preferences - “supports-discounting”: Supports time-discounted utilities

class negmas.registry.Registry(info_class: type[T])

Bases: Generic[T], dict[str, T]

A registry for storing and querying registered classes.

This is a dictionary subclass that provides additional query methods for finding classes by their properties.

Type Parameters:

T: The RegistryInfo subclass used for entries in this registry.

create(key_or_name: str, **override_params) → Any

Create an instance of a registered class.

This method instantiates a class using its stored params, merged with any override parameters provided.

Parameters:

• key_or_name – The unique key (e.g., ‘MyNegotiator#a1b2c3d4’), short name (e.g., ‘MyNegotiator’), or full type name.

• **override_params – Parameters to override the stored params.

Returns:

An instance of the registered class.

Raises:

• KeyError – If no registration is found for the given key or name.

• TypeError – If the class cannot be instantiated with the params.

Example

# Register with default params key = registry.register(MyNegotiator, params={‘alpha’: 0.5})

# Create with stored params neg1 = registry.create(key) # uses alpha=0.5

# Create with overridden params neg2 = registry.create(key, alpha=0.9) # uses alpha=0.9

get_all_by_class(cls: type | str) → list[T]

Get all registration info for a class.

Parameters:

cls – The class to look up, or its full type name string.

Returns:

A list of all RegistryInfo objects for this class, or empty list if not registered.

get_by_class(cls: type | str) → T | None

Get the first registration info for a class.

Parameters:

cls – The class to look up, or its full type name string.

Returns:

The first RegistryInfo for the class, or None if not registered. If the class has multiple registrations, returns the first one. Use get_all_by_class() to get all registrations.

get_by_short_name(short_name: str) → list[T]

Get all registrations with a given short name.

Since keys are now unique (with UUID suffix), multiple registrations can have the same short_name. This method returns all of them.

Parameters:

short_name – The short name to look up.

Returns:

A list of RegistryInfo objects with that short name (may be empty).

get_class(key_or_name: str) → type | None

Get the class for a registered key or name.

Parameters:

key_or_name – The unique key (e.g., ‘MyNegotiator#a1b2c3d4’), short name (e.g., ‘MyNegotiator’), or full type name (e.g., ‘mymodule.MyNegotiator’).

Returns:

The class, or None if not found. If multiple registrations match a short name, returns the first one found.

is_registered(cls: type | str) → bool

Check if a class is registered.

Parameters:

cls – The class to check, or its full type name string.

Returns:

True if the class has at least one registration, False otherwise.

list_all() → list[str]

List all registered keys.

Returns:

A list of all registered keys.

list_tags() → set[str]

List all unique tags used across all registered items.

Returns:

A set of all unique tags.

query(*, tags: set[str] | list[str] | tuple[str, ...] | None = None, any_tags: set[str] | list[str] | tuple[str, ...] | None = None, exclude_tags: set[str] | list[str] | tuple[str, ...] | None = None, **criteria) → dict[str, T]

Query the registry for classes matching the given criteria.

Parameters:

• tags – If provided, only return items that have ALL of these tags.

• any_tags – If provided, only return items that have ANY of these tags.

• exclude_tags – If provided, exclude items that have ANY of these tags.

• **criteria – Attribute-value pairs to match exactly.

Returns:

A dictionary of matching entries (short_name -> info).

Example

# Find all genius negotiators from ANAC 2019 negotiator_registry.query(tags={“genius”}, anac_year=2019)

# Find any builtin or genius negotiators negotiator_registry.query(any_tags={“builtin”, “genius”})

# Find builtin negotiators that are not bilateral-only negotiator_registry.query(tags={“builtin”}, bilateral_only=False)

# Find all negotiators except genius ones negotiator_registry.query(exclude_tags={“genius”})

query_by_tag(tag: str) → dict[str, T]

Query the registry for classes with a specific tag.

This is a convenience method equivalent to query(tags={tag}).

Parameters:

tag – The tag to filter by.

Returns:

A dictionary of matching entries (short_name -> info).

register(cls: type | str, short_name: str | None = None, source: str = 'unknown', description: str | None = None, params: dict[str, Any] | None = None, tags: set[str] | list[str] | tuple[str, ...] | None = None, **kwargs) → str

Register a class in the registry.

Args:

cls: The class to register, or its full type name string

(e.g., ‘negmas.sao.AspirationNegotiator’). If a string is provided, the class will be resolved using negmas helpers.

short_name: A human-readable name for this registration. Can differ from

the class name to create “virtual” negotiators with different params. If None, uses the class name. Examples: - ‘AspirationNegotiator’ (same as class) - ‘AggressiveAspiration’ (virtual negotiator with specific params)

source: The origin of this registration (‘negmas’ for built-in, library

name for external, or ‘unknown’ if not specified).

description: Markdown-formatted description of the class. If None,

automatically extracts from the class docstring.

params: Constructor parameters for creating instances via create().

This enables “virtual” negotiators that share a class but have different default parameters.

tags: Optional set of tags for categorization and filtering. **kwargs: Additional properties for the RegistryInfo. Deprecated boolean

params are converted to tags automatically.

Returns:

The unique key assigned to this registration.

Note:

The same class can be registered multiple times with different names and parameters (creating “virtual” negotiators). Each registration gets a unique key in the format ‘{short_name}#{uuid8}’.

Example:

# Register with class key1 = registry.register(AspirationNegotiator)

# Register with full type name string key2 = registry.register(‘negmas.sao.AspirationNegotiator’)

# Create a “virtual” negotiator with custom params key3 = registry.register(

AspirationNegotiator, short_name=’AggressiveAspiration’, params={‘aspiration_type’: ‘boulware’, ‘max_aspiration’: 0.95},

)

# Register with custom description key4 = registry.register(

MyNegotiator, description=’# MyNegotiator

A custom negotiator for testing.’,

)

register_many(registrations: list[dict[str, Any]], source: str | None = None) → list[str]

Register multiple classes in a single call.

Parameters:

• registrations – A list of dictionaries, each containing the arguments for a single registration. Each dict must have a ‘cls’ key with the class to register. Other keys are passed to register().

• source – Optional default source for all registrations. If a registration dict contains its own ‘source’ key, that takes precedence.

Returns:

A list of unique keys assigned to the registrations.

Example

# All get the same source keys = registry.register_many([

{‘cls’: MyNegotiator, ‘short_name’: ‘my_neg’}, {‘cls’: OtherNegotiator, ‘params’: {‘alpha’: 0.5}},

], source=’mylib’)

# Override source for specific registrations keys = registry.register_many([

{‘cls’: MyNegotiator, ‘source’: ‘mylib’}, # Uses ‘mylib’ {‘cls’: OtherNegotiator}, # Uses default source from parameter

], source=’default-lib’)

unregister(cls_or_key: type | str) → bool

Remove a registration from the registry.

Parameters:

cls_or_key – Either the class itself, a full type name string, or a registered key. If a class or full type name is given and it has multiple registrations, ALL are removed. If a key is given, only that specific registration is removed.

Returns:

True if at least one registration was removed, False if none were found.

Example

# Unregister by key (removes only that registration) registry.unregister(“MyNegotiator#a1b2c3d4”)

# Unregister by class (removes ALL registrations of this class) registry.unregister(MyNegotiator)

# Unregister by full type name (removes ALL registrations) registry.unregister(“mymodule.MyNegotiator”)

unregister_many(keys_or_classes: list[str | type]) → int

Remove multiple registrations in a single call.

Parameters:

keys_or_classes – A list of keys or classes to unregister.

Returns:

The number of registrations that were removed.

Example

count = registry.unregister_many([

‘MyNegotiator#a1b2c3d4’, OtherNegotiator, # removes all registrations of this class

])

class negmas.registry.RegistryInfo(key: str, short_name: str, full_type_name: str, cls: type, source: str = 'unknown', description: str = '', params: dict[str, ~typing.Any]=<factory>, tags: set[str] = <factory>, extra: dict[str, ~typing.Any]=<factory>)

Bases: object

Base class for registration information.

key

The unique registry key (e.g., ‘AspirationNegotiator#a1b2c3d4’). This is automatically generated and guaranteed unique within the registry.

Type:

str

short_name

A short, human-readable name for the class.

Type:

str

full_type_name

The fully qualified class name (e.g., ‘negmas.sao.SAOMechanism’).

Type:

str

cls

The actual class object.

Type:

type

source

The origin of this registration (‘negmas’ for built-in, library name for external, or ‘unknown’ if not specified).

Type:

str

description

Markdown-formatted description of the class (typically from docstring). Empty string if no description is available.

Type:

str

params

Constructor parameters for creating instances via Registry.create().

Type:

dict[str, Any]

tags

A set of string tags for categorization and filtering.

Type:

set[str]

extra

Additional key-value pairs for custom properties.

Type:

dict[str, Any]

cls: type

description: str = ''

extra: dict[str, Any]

full_type_name: str

has_all_tags(tags: set[str] | list[str] | tuple[str, ...]) → bool

Check if this item has all of the specified tags.

Parameters:

tags – The tags to check for.

Returns:

True if all of the tags are present, False otherwise.

has_any_tag(tags: set[str] | list[str] | tuple[str, ...]) → bool

Check if this item has any of the specified tags.

Parameters:

tags – The tags to check for.

Returns:

True if any of the tags is present, False otherwise.

has_tag(tag: str) → bool

Check if this item has a specific tag.

Parameters:

tag – The tag to check for.

Returns:

True if the tag is present, False otherwise.

key: str

params: dict[str, Any]

short_name: str

source: str = 'unknown'

tags: set[str]

class negmas.registry.ScenarioInfo(name: str, path: Path, source: str = 'unknown', description: str = '', tags: set[str] = <factory>, n_outcomes: int | None = None, n_negotiators: int | None = None, opposition_level: float | None = None, rational_fraction: float | None = None, read_only: bool = False, extra: dict[str, ~typing.Any]=<factory>)

Bases: object

Registration information for negotiation scenarios.

Unlike other registry entries, scenarios are paths to files/folders rather than classes.

Boolean properties are now expressed via tags: - “normalized”: Utilities are normalized to [0, 1] - “anac”: From an ANAC competition - “file”: Single file scenario (vs folder) - “has-stats”: Has pre-computed statistics - “has-plot”: Has a pre-generated plot - “xml”, “json”, “yaml”: Format tags

name

A short name for the scenario (may not be unique - typically folder/file name).

Type:

str

path

The full path to the scenario file or folder.

Type:

pathlib.Path

source

The origin of this registration (‘negmas’ for built-in, library name for external, or ‘unknown’ if not specified).

Type:

str

description

Markdown-formatted description of the scenario. Empty string if no description is available.

Type:

str

tags

A set of string tags for categorization and filtering.

Type:

set[str]

n_outcomes

The number of possible outcomes (if known).

Type:

int | None

n_negotiators

The number of negotiators in the scenario (if known).

Type:

int | None

opposition_level

The opposition level between negotiators (0=cooperative, 1=competitive).

Type:

float | None

rational_fraction

The fraction of rational outcomes (0-1) where all utilities are above reserved values.

Type:

float | None

read_only

Whether this scenario is read-only (cannot be unregistered). Built-in scenarios are read-only.

Type:

bool

extra

Additional key-value pairs for custom properties.

Type:

dict[str, Any]

description: str = ''

extra: dict[str, Any]

has_all_tags(tags: set[str] | list[str] | tuple[str, ...]) → bool

Check if this scenario has all of the specified tags.

Parameters:

tags – The tags to check for.

Returns:

True if all of the tags are present, False otherwise.

has_any_tag(tags: set[str] | list[str] | tuple[str, ...]) → bool

Check if this scenario has any of the specified tags.

Parameters:

tags – The tags to check for.

Returns:

True if any of the tags is present, False otherwise.

has_tag(tag: str) → bool

Check if this scenario has a specific tag.

Parameters:

tag – The tag to check for.

Returns:

True if the tag is present, False otherwise.

n_negotiators: int | None = None

n_outcomes: int | None = None

name: str

opposition_level: float | None = None

path: Path

rational_fraction: float | None = None

read_only: bool = False

source: str = 'unknown'

tags: set[str]

class negmas.registry.ScenarioRegistry

Bases: dict[str, ScenarioInfo]

A registry for storing and querying registered scenarios.

Unlike the regular Registry, this stores scenario paths rather than classes. Scenarios are identified by a unique key (typically the path string).

get_by_name(name: str) → list[ScenarioInfo]

Get all scenarios with a given name.

Note that scenario names are not unique, so this returns a list.

Parameters:

name – The scenario name to look up.

Returns:

A list of ScenarioInfo objects with that name (may be empty).

list_all() → list[str]

List all registered scenario paths.

Returns:

A list of all registered scenario paths (as strings).

list_names() → list[str]

List all unique scenario names.

Returns:

A list of all unique scenario names.

list_tags() → set[str]

List all unique tags used across all registered scenarios.

Returns:

A set of all unique tags.

load(key_or_name: str | Path) → Any

Load a registered scenario.

This method loads the scenario from disk using its registered path.

Parameters:

key_or_name – The path (as registered) or scenario name. If a name is given and multiple scenarios have that name, loads the first one found.

Returns:

The loaded Scenario object.

Raises:

• KeyError – If no registration is found for the given key or name.

• Exception – If the scenario cannot be loaded.

Example

# Load by path (key) scenario = registry.load(‘/path/to/scenario’)

# Load by name scenario = registry.load(‘Laptop’)

query(*, tags: set[str] | list[str] | tuple[str, ...] | None = None, any_tags: set[str] | list[str] | tuple[str, ...] | None = None, exclude_tags: set[str] | list[str] | tuple[str, ...] | None = None, n_outcomes: int | tuple[int | None, int | None] | None = None, n_negotiators: int | tuple[int | None, int | None] | None = None, opposition_level: float | tuple[float | None, float | None] | None = None, rational_fraction: float | tuple[float | None, float | None] | None = None, format: str | None = None, anac: bool | None = None, normalized: bool | None = None, file: bool | None = None, **criteria) → dict[str, ScenarioInfo]

Query the registry for scenarios matching the given criteria.

Parameters:

• tags – If provided, only return items that have ALL of these tags.

• any_tags – If provided, only return items that have ANY of these tags.

• exclude_tags – If provided, exclude items that have ANY of these tags.

• n_outcomes – Filter by number of outcomes. Can be exact value or (min, max) tuple.

• n_negotiators – Filter by number of negotiators. Can be exact value or (min, max) tuple.

• opposition_level – Filter by opposition level. Can be exact value or (min, max) tuple.

• rational_fraction – Filter by rational fraction. Can be exact value or (min, max) tuple.

• format – DEPRECATED. Use tags={‘xml’} or tags={‘json’} instead.

• anac – DEPRECATED. Use tags={‘anac’} instead.

• normalized – DEPRECATED. Use tags={‘normalized’} instead.

• file – DEPRECATED. Use tags={‘file’} instead.

• **criteria – Additional attribute-value pairs to match exactly.

Returns:

A dictionary of matching entries (path -> info).

query_by_tag(tag: str) → dict[str, ScenarioInfo]

Query the registry for scenarios with a specific tag.

This is a convenience method equivalent to query(tags={tag}).

Parameters:

tag – The tag to filter by.

Returns:

A dictionary of matching entries (path -> info).

register(path: str | Path, name: str | None = None, source: str = 'unknown', description: str = '', tags: set[str] | list[str] | tuple[str, ...] | None = None, n_outcomes: int | None = None, n_negotiators: int | None = None, opposition_level: float | None = None, rational_fraction: float | None = None, read_only: bool = False, normalized: bool | None = None, anac: bool | None = None, has_stats: bool = False, has_plot: bool = False, **extra) → ScenarioInfo

Register a scenario in the registry.

Parameters:

• path – The path to the scenario file or folder.

• name – A short name for the scenario. If None, uses the file/folder name.

• source – The origin of this registration (‘negmas’ for built-in, library name for external, or ‘unknown’ if not specified).

• description – Markdown-formatted description of the scenario. Can be loaded from _info.yaml or provided explicitly.

• tags – Optional set of tags for categorization and filtering.

• n_outcomes – The number of possible outcomes.

• n_negotiators – The number of negotiators in the scenario.

• opposition_level – The opposition level between negotiators (0-1).

• rational_fraction – The fraction of rational outcomes (0-1).

• read_only – Whether this scenario is read-only (cannot be unregistered).

• normalized – DEPRECATED. Use tags={‘normalized’} instead.

• anac – DEPRECATED. Use tags={‘anac’} instead.

• has_stats – DEPRECATED. Use tags={‘has-stats’} instead.

• has_plot – DEPRECATED. Use tags={‘has-plot’} instead.

• **extra – Additional properties to store.

Returns:

The ScenarioInfo object that was created, or the existing one if already registered.

Note

If the path is already registered, returns the existing registration without modifying it. Registrations never overwrite existing entries.

register_many(registrations: list[dict[str, Any]], source: str | None = None) → list[ScenarioInfo]

Register multiple scenarios in a single call.

Parameters:

• registrations – A list of dictionaries, each containing the arguments for a single registration. Each dict must have a ‘path’ key with the path to the scenario. Other keys are passed to register().

• source – Optional default source for all registrations. If a registration dict contains its own ‘source’ key, that takes precedence.

Returns:

A list of ScenarioInfo objects for the registered scenarios.

Example

# All get the same source infos = registry.register_many([

{‘path’: ‘/path/to/scenario1’, ‘tags’: {‘custom’}}, {‘path’: ‘/path/to/scenario2’, ‘n_negotiators’: 2},

], source=’mylib’)

# Override source for specific registrations infos = registry.register_many([

{‘path’: ‘/path/to/scenario1’, ‘source’: ‘mylib’}, # Uses ‘mylib’ {‘path’: ‘/path/to/scenario2’}, # Uses default source from parameter

], source=’default-lib’)

unregister(path_or_name: str | Path) → bool

Remove a scenario from the registry.

Parameters:

path_or_name – Either the path (as string or Path) or the scenario name. If a name is given and multiple scenarios have that name, all are removed.

Returns:

True if at least one scenario was removed, False if none were found.

Note

The read_only property is informational only and does not prevent unregistration.

Example

# Unregister by path registry.unregister(“/path/to/scenario”)

# Unregister by name (removes all with that name) registry.unregister(“Laptop”)

unregister_many(paths_or_names: list[str | Path]) → int

Remove multiple scenarios in a single call.

Parameters:

paths_or_names – A list of paths or names to unregister. If a name is given and multiple scenarios have that name, all are removed.

Returns:

The number of scenarios that were removed.

Example

count = registry.unregister_many([

‘/path/to/scenario1’, ‘MyScenario’, # removes all with this name

])

negmas.registry.clear_registry(*, include_mechanisms: bool = True, include_negotiators: bool = True, include_components: bool = True, include_scenarios: bool = True) → None

Clear all global registries.

This removes all registrations from the specified registries.

Parameters:

• include_mechanisms – Whether to clear the mechanism registry.

• include_negotiators – Whether to clear the negotiator registry.

• include_components – Whether to clear the component registry.

• include_scenarios – Whether to clear the scenario registry.

Example

# Clear all registries clear_registry()

# Clear only negotiators clear_registry(

include_mechanisms=False, include_components=False, include_scenarios=False,

)

negmas.registry.component_registry: Registry[ComponentInfo] = {'ACConst#273721fe': ComponentInfo(key='ACConst#273721fe', short_name='ACConst', full_type_name='negmas.gb.components.acceptance.ACConst', cls=<class 'negmas.gb.components.acceptance.ACConst'>, source='negmas', description='Accepts outcomes with utilities above the given threshold', params={}, tags={'sao', 'builtin', 'acceptance', 'threshold'}, extra={}, component_type='acceptance'), 'ACLast#10785e7f': ComponentInfo(key='ACLast#10785e7f', short_name='ACLast', full_type_name='negmas.gb.components.acceptance.ACLast', cls=<class 'negmas.gb.components.acceptance.ACLast'>, source='negmas', description='Implements the AClast acceptance strategy based on our last offer.\n\nAccepts $\\omega$ if $\x07lpha u(my-next-offer) + \x08eta > u(\\omega)$', params={}, tags={'sao', 'builtin', 'acceptance', 'adaptive'}, extra={}, component_type='acceptance'), 'ACLastFractionReceived#4fd38691': ComponentInfo(key='ACLastFractionReceived#4fd38691', short_name='ACLastFractionReceived', full_type_name='negmas.gb.components.acceptance.ACLastFractionReceived', cls=<class 'negmas.gb.components.acceptance.ACLastFractionReceived'>, source='negmas', description='Accepts $\\omega$ if $\x07lpha u(my-next-offer) + \x08eta > f(u(   ext{utils of offers received in the given fraction of time}))$', params={}, tags={'sao', 'builtin', 'acceptance', 'adaptive'}, extra={}, component_type='acceptance'), 'ACLastKReceived#e62cb095': ComponentInfo(key='ACLastKReceived#e62cb095', short_name='ACLastKReceived', full_type_name='negmas.gb.components.acceptance.ACLastKReceived', cls=<class 'negmas.gb.components.acceptance.ACLastKReceived'>, source='negmas', description='Accepts $\\omega$ if $\x07lpha u(my-next-offer) + \x08eta > f(u(   ext{utils of offers received in the last k steps))$', params={}, tags={'sao', 'builtin', 'acceptance', 'adaptive'}, extra={}, component_type='acceptance'), 'ACNext#51739d6b': ComponentInfo(key='ACNext#51739d6b', short_name='ACNext', full_type_name='negmas.gb.components.acceptance.ACNext', cls=<class 'negmas.gb.components.acceptance.ACNext'>, source='negmas', description='Implements the ACnext acceptance strategy based on our next offer.\n\nAccepts $\\omega$ if $\x07lpha u(my-next-offer) + \x08eta > u(\\omega)$', params={}, tags={'sao', 'builtin', 'acceptance', 'adaptive'}, extra={}, component_type='acceptance'), 'ACTime#8b7e69dc': ComponentInfo(key='ACTime#8b7e69dc', short_name='ACTime', full_type_name='negmas.gb.components.acceptance.ACTime', cls=<class 'negmas.gb.components.acceptance.ACTime'>, source='negmas', description='Implements the ACtime acceptance strategy based on our next offer.\n\nAccepts if the relative time is greater than or equal to tau', params={}, tags={'sao', 'builtin', 'acceptance', 'time-based'}, extra={}, component_type='acceptance'), 'ACTime#ca66b45b': ComponentInfo(key='ACTime#ca66b45b', short_name='ACTime', full_type_name='negmas.gb.components.acceptance.ACTime', cls=<class 'negmas.gb.components.acceptance.ACTime'>, source='negmas', description='Implements the ACtime acceptance strategy based on our next offer.\n\nAccepts if the relative time is greater than or equal to tau', params={}, tags={'sao', 'builtin', 'acceptance', 'time-based'}, extra={}, component_type='acceptance'), 'AcceptAbove#b041cc00': ComponentInfo(key='AcceptAbove#b041cc00', short_name='AcceptAbove', full_type_name='negmas.gb.components.acceptance.AcceptAbove', cls=<class 'negmas.gb.components.acceptance.AcceptAbove'>, source='negmas', description='Accepts outcomes with utilities in the given top `limit` fraction above reserve/minimum (based on `above_resrve` ).', params={}, tags={'sao', 'builtin', 'acceptance', 'threshold'}, extra={}, component_type='acceptance'), 'AcceptAnyRational#2de32ab5': ComponentInfo(key='AcceptAnyRational#2de32ab5', short_name='AcceptAnyRational', full_type_name='negmas.gb.components.acceptance.AcceptAnyRational', cls=<class 'negmas.gb.components.acceptance.AcceptAnyRational'>, source='negmas', description='Accepts any rational outcome.', params={}, tags={'sao', 'rational', 'builtin', 'acceptance'}, extra={}, component_type='acceptance'), 'AcceptAround#2e42bb16': ComponentInfo(key='AcceptAround#2e42bb16', short_name='AcceptAround', full_type_name='negmas.gb.components.acceptance.AcceptAround', cls=<class 'negmas.gb.components.acceptance.AcceptAround'>, source='negmas', description='Accepts around the given relative time (i.e. eps from it)', params={}, tags={'sao', 'builtin', 'acceptance', 'threshold'}, extra={}, component_type='acceptance'), 'AcceptBest#c98f3236': ComponentInfo(key='AcceptBest#c98f3236', short_name='AcceptBest', full_type_name='negmas.gb.components.acceptance.AcceptBest', cls=<class 'negmas.gb.components.acceptance.AcceptBest'>, source='negmas', description='Accepts Only the best outcome.\n\nRemarks:\n    - If the best possible utility cannot be found, nothing will be accepted', params={}, tags={'sao', 'builtin', 'acceptance', 'optimal'}, extra={}, component_type='acceptance'), 'AcceptBetterRational#2ac0cd4c': ComponentInfo(key='AcceptBetterRational#2ac0cd4c', short_name='AcceptBetterRational', full_type_name='negmas.gb.components.acceptance.AcceptBetterRational', cls=<class 'negmas.gb.components.acceptance.AcceptBetterRational'>, source='negmas', description='Accept first rational outcomes and then accept only outcomes better than the all accepted so far.', params={}, tags={'sao', 'rational', 'builtin', 'acceptance'}, extra={}, component_type='acceptance'), 'AcceptBetween#32f77c00': ComponentInfo(key='AcceptBetween#32f77c00', short_name='AcceptBetween', full_type_name='negmas.gb.components.acceptance.AcceptBetween', cls=<class 'negmas.gb.components.acceptance.AcceptBetween'>, source='negmas', description='Accepts in the given range of relative times.', params={}, tags={'sao', 'builtin', 'acceptance', 'threshold'}, extra={}, component_type='acceptance'), 'AcceptImmediately#5aacda1e': ComponentInfo(key='AcceptImmediately#5aacda1e', short_name='AcceptImmediately', full_type_name='negmas.gb.components.acceptance.AcceptImmediately', cls=<class 'negmas.gb.components.acceptance.AcceptImmediately'>, source='negmas', description='Accepts immediately anything', params={}, tags={'sao', 'builtin', 'acceptance', 'simple'}, extra={}, component_type='acceptance'), 'AcceptNotWorseRational#0b4c0e41': ComponentInfo(key='AcceptNotWorseRational#0b4c0e41', short_name='AcceptNotWorseRational', full_type_name='negmas.gb.components.acceptance.AcceptNotWorseRational', cls=<class 'negmas.gb.components.acceptance.AcceptNotWorseRational'>, source='negmas', description='Accept any outcome not worse than the best so far.', params={}, tags={'sao', 'rational', 'builtin', 'acceptance'}, extra={}, component_type='acceptance'), 'AcceptTop#b09491a3': ComponentInfo(key='AcceptTop#b09491a3', short_name='AcceptTop', full_type_name='negmas.gb.components.acceptance.AcceptTop', cls=<class 'negmas.gb.components.acceptance.AcceptTop'>, source='negmas', description='Accepts outcomes that are in the given top fraction or top `k`. If neither is given it reverts to accepting the best outcome only.\n\nRemarks:\n    - The outcome-space is always discretized and the constraints `fraction` and `k` are applied to the discretized space', params={}, tags={'sao', 'builtin', 'acceptance', 'optimal'}, extra={}, component_type='acceptance'), 'EndImmediately#c47ce75f': ComponentInfo(key='EndImmediately#c47ce75f', short_name='EndImmediately', full_type_name='negmas.gb.components.acceptance.EndImmediately', cls=<class 'negmas.gb.components.acceptance.EndImmediately'>, source='negmas', description='Ends negotiation immediately regardless of the offer.', params={}, tags={'sao', 'builtin', 'acceptance', 'simple'}, extra={}, component_type='acceptance'), 'FrequencyLinearUFunModel#8e051793': ComponentInfo(key='FrequencyLinearUFunModel#8e051793', short_name='FrequencyLinearUFunModel', full_type_name='negmas.sao.components.models.ufun.FrequencyLinearUFunModel', cls=<class 'negmas.sao.components.models.ufun.FrequencyLinearUFunModel'>, source='negmas', description='A `PartnerUfunModel` that uses a simple frequency-based model of the opponent offers assuming the ufun is `LinearAdditiveUtilityFunction` .', params={}, tags={'model', 'builtin', 'sao', 'frequency', 'learning', 'linear'}, extra={}, component_type='model'), 'FrequencyUFunModel#701bbeec': ComponentInfo(key='FrequencyUFunModel#701bbeec', short_name='FrequencyUFunModel', full_type_name='negmas.sao.components.models.ufun.FrequencyUFunModel', cls=<class 'negmas.sao.components.models.ufun.FrequencyUFunModel'>, source='negmas', description='A `PartnerUfunModel` that uses a simple frequency-based model of the opponent offers.', params={}, tags={'sao', 'frequency', 'builtin', 'learning', 'model'}, extra={}, component_type='model'), 'GACABMP#5e69f1ef': ComponentInfo(key='GACABMP#5e69f1ef', short_name='GACABMP', full_type_name='negmas.gb.components.genius.acceptance.GACABMP', cls=<class 'negmas.gb.components.genius.acceptance.GACABMP'>, source='negmas', description="AC_ABMP acceptance strategy from Genius.\n\nAccepts an offer if the opponent's utility is within a gap of our last offer.\nBased on the ABMP (Adaptive Bargaining with Multiple Proposals) agent.\n\nArgs:\n    utility_gap: The maximum gap between opponent's offer and our last offer (default 0.05).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_ABMP", params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'genius-translated', 'anac2010'}, extra={}, component_type='acceptance'), 'GACAgentFSEGA#ee41821b': ComponentInfo(key='GACAgentFSEGA#ee41821b', short_name='GACAgentFSEGA', full_type_name='negmas.gb.components.genius.acceptance.GACAgentFSEGA', cls=<class 'negmas.gb.components.genius.acceptance.GACAgentFSEGA'>, source='negmas', description="AC_AgentFSEGA acceptance strategy from Genius (ANAC2010).\n\nAccepts if:\n- opponent_util * multiplier >= my_last_util, OR\n- opponent_util > my_next_util, OR\n- opponent_util == max_utility_in_domain\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n    multiplier: Multiplier for opponent's offer comparison (default 1.03).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2010.AC_AgentFSEGA", params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'genius-translated', 'anac2010'}, extra={}, component_type='acceptance'), 'GACAgentK#a000063f': ComponentInfo(key='GACAgentK#a000063f', short_name='GACAgentK', full_type_name='negmas.gb.components.genius.acceptance.GACAgentK', cls=<class 'negmas.gb.components.genius.acceptance.GACAgentK'>, source='negmas', description="AC_AgentK acceptance strategy from Genius (ANAC2010).\n\nProbabilistic acceptance based on time and utility. Calculates an acceptance\nprobability and accepts if a random value is below this probability.\n\nThe acceptance probability increases as time progresses and as the opponent's\noffers improve relative to expectations.\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2010.AC_AgentK", params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'genius-translated', 'anac2010'}, extra={}, component_type='acceptance'), 'GACAgentK2#1fbd46dc': ComponentInfo(key='GACAgentK2#1fbd46dc', short_name='GACAgentK2', full_type_name='negmas.gb.components.genius.acceptance.GACAgentK2', cls=<class 'negmas.gb.components.genius.acceptance.GACAgentK2'>, source='negmas', description='AC_AgentK2 acceptance strategy from Genius (ANAC2011).\n\nEnhanced probabilistic acceptance with statistics tracking.\nSimilar to AgentK but with improved probability calculations.\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_AgentK2', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2011', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACAgentLG#708d5142': ComponentInfo(key='GACAgentLG#708d5142', short_name='GACAgentLG', full_type_name='negmas.gb.components.genius.acceptance.GACAgentLG', cls=<class 'negmas.gb.components.genius.acceptance.GACAgentLG'>, source='negmas', description='AC_AgentLG acceptance strategy from Genius (ANAC2012).\n\nFrequency-based acceptance that tracks opponent bids and accepts\nbased on relative utility and time pressure.\n\nArgs:\n    accept_ratio: Ratio for acceptance comparison (default 0.99).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2012.AC_AgentLG', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2012', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACAgentMR#86312e9c': ComponentInfo(key='GACAgentMR#86312e9c', short_name='GACAgentMR', full_type_name='negmas.gb.components.genius.acceptance.GACAgentMR', cls=<class 'negmas.gb.components.genius.acceptance.GACAgentMR'>, source='negmas', description='AC_AgentMR acceptance strategy from Genius (ANAC2012).\n\nTime-based concession with sigmoid acceptance probability.\nTracks opponent offers and adjusts acceptance based on forecasting.\n\nArgs:\n    minimum_accept_p: Minimum acceptance probability threshold (default 0.965).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2012.AC_AgentMR', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2012', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACAgentSmith#efefc319': ComponentInfo(key='GACAgentSmith#efefc319', short_name='GACAgentSmith', full_type_name='negmas.gb.components.genius.acceptance.GACAgentSmith', cls=<class 'negmas.gb.components.genius.acceptance.GACAgentSmith'>, source='negmas', description="AC_AgentSmith acceptance strategy from Genius (ANAC2010).\n\nProbabilistic acceptance with a minimum utility threshold.\nAccepts if opponent's offer is above the accept margin or\nif it's better than or equal to our last offer.\n\nArgs:\n    accept_margin: Minimum utility to accept unconditionally (default 0.9).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2010.AC_AgentSmith", params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'genius-translated', 'anac2010'}, extra={}, component_type='acceptance'), 'GACBRAMAgent#7600b1c6': ComponentInfo(key='GACBRAMAgent#7600b1c6', short_name='GACBRAMAgent', full_type_name='negmas.gb.components.genius.acceptance.GACBRAMAgent', cls=<class 'negmas.gb.components.genius.acceptance.GACBRAMAgent'>, source='negmas', description='AC_BRAMAgent acceptance strategy from Genius (ANAC2011).\n\nBest Response Adaptive Model - accepts based on a dynamically\ncalculated threshold that accounts for discounting.\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_BRAMAgent', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2011', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACBRAMAgent2#6bf5c65e': ComponentInfo(key='GACBRAMAgent2#6bf5c65e', short_name='GACBRAMAgent2', full_type_name='negmas.gb.components.genius.acceptance.GACBRAMAgent2', cls=<class 'negmas.gb.components.genius.acceptance.GACBRAMAgent2'>, source='negmas', description='AC_BRAMAgent2 acceptance strategy from Genius (ANAC2012).\n\nEnhanced BRAM with better threshold adaptation. Similar to BRAMAgent\nbut with improved handling of edge cases.\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2012.AC_BRAMAgent2', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2012', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCUHKAgent#ff4bbcf7': ComponentInfo(key='GACCUHKAgent#ff4bbcf7', short_name='GACCUHKAgent', full_type_name='negmas.gb.components.genius.acceptance.GACCUHKAgent', cls=<class 'negmas.gb.components.genius.acceptance.GACCUHKAgent'>, source='negmas', description='AC_CUHKAgent acceptance strategy from Genius (ANAC2012).\n\nComplex acceptance with concede degree calculation. Accepts based on\nthreshold that adapts to discounting and opponent behavior.\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n    min_threshold: Minimum utility threshold (default 0.65).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2012.AC_CUHKAgent', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2012', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombi#e0d55e8a': ComponentInfo(key='GACCombi#e0d55e8a', short_name='GACCombi', full_type_name='negmas.gb.components.genius.acceptance.GACCombi', cls=<class 'negmas.gb.components.genius.acceptance.GACCombi'>, source='negmas', description="AC_Combi acceptance strategy from Genius.\n\nCombines AC_Next and AC_Time: accepts if either condition is met.\n\nAccepts if:\n    (a * u(opponent_offer) + b >= u(my_next_offer)) OR (time >= t)\n\nArgs:\n    offering_policy: The offering strategy used to determine my next offer.\n    a: Scaling factor for opponent's offer utility (default 1.0).\n    b: Offset added to scaled opponent utility (default 0.0).\n    t: Time threshold for acceptance (default 0.99).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_Combi", params={}, tags={'genius', 'ai-generated', 'combined', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiAvg#e1f95028': ComponentInfo(key='GACCombiAvg#e1f95028', short_name='GACCombiAvg', full_type_name='negmas.gb.components.genius.acceptance.GACCombiAvg', cls=<class 'negmas.gb.components.genius.acceptance.GACCombiAvg'>, source='negmas', description="AC_CombiAvg acceptance strategy from Genius.\n\nCombines AC_Next with average-based acceptance in the end game.\n\nBefore time t: acts like AC_Next.\nAfter time t: accepts if opponent's offer >= average of opponent's offers in window.\n\nArgs:\n    offering_policy: The offering strategy used to determine my next offer.\n    t: Time threshold after which average-based acceptance kicks in (default 0.98).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_CombiAvg", params={}, tags={'genius', 'ai-generated', 'combined', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiBestAvg#38c10b73': ComponentInfo(key='GACCombiBestAvg#38c10b73', short_name='GACCombiBestAvg', full_type_name='negmas.gb.components.genius.acceptance.GACCombiBestAvg', cls=<class 'negmas.gb.components.genius.acceptance.GACCombiBestAvg'>, source='negmas', description="AC_CombiBestAvg acceptance strategy from Genius.\n\nCombines AC_Next with best-average-based acceptance.\n\nBefore time t: acts like AC_Next.\nAfter time t: accepts if opponent's offer >= average of offers better than current offer.\n\nArgs:\n    offering_policy: The offering strategy used to determine my next offer.\n    t: Time threshold after which best-average acceptance kicks in (default 0.98).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_CombiBestAvg", params={}, tags={'genius', 'ai-generated', 'combined', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiBestAvgDiscounted#9f841485': ComponentInfo(key='GACCombiBestAvgDiscounted#9f841485', short_name='GACCombiBestAvgDiscounted', full_type_name='negmas.gb.components.genius.acceptance.GACCombiBestAvgDiscounted', cls=<class 'negmas.gb.components.genius.acceptance.GACCombiBestAvgDiscounted'>, source='negmas', description='AC_CombiBestAvgDiscounted acceptance strategy from Genius.\n\nLike AC_CombiBestAvg but applies time discount to utilities.\n\nBefore time t: acts like AC_Next.\nAfter time t: accepts if discounted opponent offer >= discounted avg of better offers.\n\nArgs:\n    offering_policy: The offering strategy used to determine my next offer.\n    t: Time threshold after which best-average acceptance kicks in (default 0.98).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_CombiBestAvgDiscounted', params={}, tags={'genius', 'ai-generated', 'discounted', 'combined', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiMax#fef8134e': ComponentInfo(key='GACCombiMax#fef8134e', short_name='GACCombiMax', full_type_name='negmas.gb.components.genius.acceptance.GACCombiMax', cls=<class 'negmas.gb.components.genius.acceptance.GACCombiMax'>, source='negmas', description="AC_CombiMax acceptance strategy from Genius.\n\nCombines AC_Next with maximum-based acceptance.\n\nBefore time t: acts like AC_Next.\nAfter time t: accepts if opponent's offer >= max of all previous opponent offers.\n\nArgs:\n    offering_policy: The offering strategy used to determine my next offer.\n    t: Time threshold after which max-based acceptance kicks in (default 0.98).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_CombiMax", params={}, tags={'genius', 'ai-generated', 'combined', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiMaxInWindow#75c94f5e': ComponentInfo(key='GACCombiMaxInWindow#75c94f5e', short_name='GACCombiMaxInWindow', full_type_name='negmas.gb.components.genius.acceptance.GACCombiMaxInWindow', cls=<class 'negmas.gb.components.genius.acceptance.GACCombiMaxInWindow'>, source='negmas', description="AC_CombiMaxInWindow acceptance strategy from Genius.\n\nCombines AC_Next with a time-window-based acceptance criterion.\n\nBefore time t: acts like AC_Next only.\nAfter time t: accepts if opponent's offer is >= best offer seen in remaining time window.\n\nArgs:\n    offering_policy: The offering strategy used to determine my next offer.\n    t: Time threshold after which window-based acceptance kicks in (default 0.98).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_CombiMaxInWindow", params={}, tags={'genius', 'ai-generated', 'combined', 'acceptance', 'windowed', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiMaxInWindowDiscounted#45bfc664': ComponentInfo(key='GACCombiMaxInWindowDiscounted#45bfc664', short_name='GACCombiMaxInWindowDiscounted', full_type_name='negmas.gb.components.genius.acceptance.GACCombiMaxInWindowDiscounted', cls=<class 'negmas.gb.components.genius.acceptance.GACCombiMaxInWindowDiscounted'>, source='negmas', description='AC_CombiMaxInWindowDiscounted acceptance strategy from Genius.\n\nLike AC_CombiMaxInWindow but applies time discount to utilities.\n\nBefore time t: acts like AC_Next.\nAfter time t: accepts if discounted offer >= discounted best in window.\n\nArgs:\n    offering_policy: The offering strategy used to determine my next offer.\n    t: Time threshold after which window-based acceptance kicks in (default 0.98).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_CombiMaxInWindowDiscounted', params={}, tags={'discounted', 'combined', 'acceptance', 'boa', 'gb', 'genius-translated', 'genius', 'windowed', 'ai-generated'}, extra={}, component_type='acceptance'), 'GACCombiProb#79cbf8d6': ComponentInfo(key='GACCombiProb#79cbf8d6', short_name='GACCombiProb', full_type_name='negmas.gb.components.genius.acceptance.GACCombiProb', cls=<class 'negmas.gb.components.genius.acceptance.GACCombiProb'>, source='negmas', description='AC_CombiProb acceptance strategy from Genius.\n\nProbability-based acceptance that combines AC_Next with probabilistic\nacceptance based on the expected utility of waiting.\n\nBefore time t: acts like AC_Next.\nAfter time t: accepts with probability based on how good the offer is\nrelative to expected future offers.\n\nArgs:\n    offering_policy: The offering strategy used to determine my next offer.\n    t: Time threshold after which probabilistic acceptance kicks in (default 0.98).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_CombiProb', params={}, tags={'genius', 'ai-generated', 'combined', 'acceptance', 'boa', 'probabilistic', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiProbDiscounted#ed3d12af': ComponentInfo(key='GACCombiProbDiscounted#ed3d12af', short_name='GACCombiProbDiscounted', full_type_name='negmas.gb.components.genius.acceptance.GACCombiProbDiscounted', cls=<class 'negmas.gb.components.genius.acceptance.GACCombiProbDiscounted'>, source='negmas', description='AC_CombiProbDiscounted acceptance strategy from Genius.\n\nLike AC_CombiProb but applies time discount to utilities.\n\nBefore time t: acts like AC_Next.\nAfter time t: probabilistic acceptance with discounted utilities.\n\nArgs:\n    offering_policy: The offering strategy used to determine my next offer.\n    t: Time threshold after which probabilistic acceptance kicks in (default 0.98).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_CombiProbDiscounted', params={}, tags={'combined', 'discounted', 'acceptance', 'boa', 'gb', 'genius-translated', 'genius', 'probabilistic', 'ai-generated'}, extra={}, component_type='acceptance'), 'GACCombiV2#fd56474d': ComponentInfo(key='GACCombiV2#fd56474d', short_name='GACCombiV2', full_type_name='negmas.gb.components.genius.acceptance.GACCombiV2', cls=<class 'negmas.gb.components.genius.acceptance.GACCombiV2'>, source='negmas', description="AC_CombiV2 acceptance strategy from Genius.\n\nA variant of AC_Combi that uses a different combination logic.\nAccepts if the opponent's offer utility exceeds a time-dependent threshold\nbased on both the next offer utility and a decay factor.\n\nBefore time t: acts like AC_Next.\nAfter time t: accepts if opponent's offer >= next offer utility * decay.\n\nArgs:\n    offering_policy: The offering strategy used to determine my next offer.\n    a: Scaling factor for opponent's offer utility (default 1.0).\n    b: Offset added to scaled opponent utility (default 0.0).\n    t: Time threshold (default 0.99).\n    decay: Decay factor applied after time threshold (default 0.9).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_CombiV2", params={}, tags={'genius', 'ai-generated', 'combined', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiV3#a670b123': ComponentInfo(key='GACCombiV3#a670b123', short_name='GACCombiV3', full_type_name='negmas.gb.components.genius.acceptance.GACCombiV3', cls=<class 'negmas.gb.components.genius.acceptance.GACCombiV3'>, source='negmas', description="AC_CombiV3 acceptance strategy from Genius.\n\nA variant of AC_Combi that uses linear interpolation between\nAC_Next threshold and reserved value based on time.\n\nThe acceptance threshold decreases linearly from next offer utility\nto reserved value as time progresses past threshold t.\n\nArgs:\n    offering_policy: The offering strategy used to determine my next offer.\n    a: Scaling factor for opponent's offer utility (default 1.0).\n    b: Offset added to scaled opponent utility (default 0.0).\n    t: Time threshold when interpolation begins (default 0.95).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_CombiV3", params={}, tags={'genius', 'ai-generated', 'combined', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiV4#d9ef3ea1': ComponentInfo(key='GACCombiV4#d9ef3ea1', short_name='GACCombiV4', full_type_name='negmas.gb.components.genius.acceptance.GACCombiV4', cls=<class 'negmas.gb.components.genius.acceptance.GACCombiV4'>, source='negmas', description="AC_CombiV4 acceptance strategy from Genius.\n\nA variant of AC_Combi that combines AC_Next with a weighted combination\nof max and average opponent offers in the end game.\n\nBefore time t: acts like AC_Next.\nAfter time t: accepts if opponent's offer >= weighted combo of max and avg.\n\nArgs:\n    offering_policy: The offering strategy used to determine my next offer.\n    t: Time threshold after which combined strategy kicks in (default 0.98).\n    w: Weight for max utility (1-w used for avg utility) (default 0.5).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_CombiV4", params={}, tags={'genius', 'ai-generated', 'combined', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACConst#b6ec6ce1': ComponentInfo(key='GACConst#b6ec6ce1', short_name='GACConst', full_type_name='negmas.gb.components.genius.acceptance.GACConst', cls=<class 'negmas.gb.components.genius.acceptance.GACConst'>, source='negmas', description='AC_Const acceptance strategy from Genius.\n\nAccepts an offer if its utility exceeds a constant threshold.\n\nArgs:\n    c: Constant threshold. Accept if utility > c (default 0.9).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_Const', params={}, tags={'genius', 'threshold', 'ai-generated', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACConstDiscounted#900be79d': ComponentInfo(key='GACConstDiscounted#900be79d', short_name='GACConstDiscounted', full_type_name='negmas.gb.components.genius.acceptance.GACConstDiscounted', cls=<class 'negmas.gb.components.genius.acceptance.GACConstDiscounted'>, source='negmas', description='AC_ConstDiscounted acceptance strategy from Genius.\n\nAccepts an offer if its discounted utility exceeds a constant threshold.\nTakes time discount into account.\n\nArgs:\n    c: Constant threshold. Accept if discounted utility > c (default 0.9).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_ConstDiscounted', params={}, tags={'genius', 'threshold', 'ai-generated', 'discounted', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACFalse#72a7d73e': ComponentInfo(key='GACFalse#72a7d73e', short_name='GACFalse', full_type_name='negmas.gb.components.genius.acceptance.GACFalse', cls=<class 'negmas.gb.components.genius.acceptance.GACFalse'>, source='negmas', description='AC_False acceptance strategy from Genius.\n\nNever accepts any offer. Useful for debugging and testing.\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_False', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'simple', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACGahboninho#2bbd874f': ComponentInfo(key='GACGahboninho#2bbd874f', short_name='GACGahboninho', full_type_name='negmas.gb.components.genius.acceptance.GACGahboninho', cls=<class 'negmas.gb.components.genius.acceptance.GACGahboninho'>, source='negmas', description='AC_Gahboninho acceptance strategy from Genius (ANAC2011).\n\nHigh threshold strategy that accepts offers above 0.95 utility early,\nor above a minimum acceptable threshold that adapts over time.\n\nArgs:\n    high_threshold: Utility threshold for early acceptance (default 0.95).\n    min_acceptable: Minimum acceptable utility (default 0.7).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_Gahboninho', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2011', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACGap#814191e7': ComponentInfo(key='GACGap#814191e7', short_name='GACGap', full_type_name='negmas.gb.components.genius.acceptance.GACGap', cls=<class 'negmas.gb.components.genius.acceptance.GACGap'>, source='negmas', description='AC_Gap acceptance strategy from Genius.\n\nAccepts an offer if:\n    u(opponent_offer) + c >= u(my_previous_offer)\n\nA restricted version of AC_Previous with a=1 and configurable gap.\n\nArgs:\n    c: Gap constant added to opponent utility (default 0.01).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_Gap', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'genius-translated', 'adaptive'}, extra={}, component_type='acceptance'), 'GACHardHeaded#85912a10': ComponentInfo(key='GACHardHeaded#85912a10', short_name='GACHardHeaded', full_type_name='negmas.gb.components.genius.acceptance.GACHardHeaded', cls=<class 'negmas.gb.components.genius.acceptance.GACHardHeaded'>, source='negmas', description="AC_HardHeaded acceptance strategy from Genius (ANAC2011).\n\nAccepts if the opponent's offer utility is greater than our lowest\noffered utility so far, or if it's at least as good as our next bid.\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_HardHeaded", params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2011', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACIAMCrazyHaggler#d0f50714': ComponentInfo(key='GACIAMCrazyHaggler#d0f50714', short_name='GACIAMCrazyHaggler', full_type_name='negmas.gb.components.genius.acceptance.GACIAMCrazyHaggler', cls=<class 'negmas.gb.components.genius.acceptance.GACIAMCrazyHaggler'>, source='negmas', description="AC_IAMcrazyHaggler acceptance strategy from Genius (ANAC2010).\n\nA high-aspiration strategy that accepts only when the opponent's offer\nis close to our maximum aspiration or our own offers.\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n    maximum_aspiration: Target utility threshold (default 0.85).\n    accept_multiplier: Multiplier for acceptance comparison (default 1.02).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2010.AC_IAMcrazyHaggler", params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'genius-translated', 'anac2010'}, extra={}, component_type='acceptance'), 'GACIAMHaggler2010#ac116394': ComponentInfo(key='GACIAMHaggler2010#ac116394', short_name='GACIAMHaggler2010', full_type_name='negmas.gb.components.genius.acceptance.GACIAMHaggler2010', cls=<class 'negmas.gb.components.genius.acceptance.GACIAMHaggler2010'>, source='negmas', description='AC_IAMHaggler2010 acceptance strategy from Genius (ANAC2010).\n\nSimilar to IAMCrazyHaggler but with slightly different thresholds.\nUses concession rate estimation for acceptance.\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n    maximum_aspiration: Target utility threshold (default 0.9).\n    accept_multiplier: Multiplier for acceptance comparison (default 1.02).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2010.AC_IAMHaggler2010', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'genius-translated', 'anac2010'}, extra={}, component_type='acceptance'), 'GACIAMHaggler2011#c95cd15b': ComponentInfo(key='GACIAMHaggler2011#c95cd15b', short_name='GACIAMHaggler2011', full_type_name='negmas.gb.components.genius.acceptance.GACIAMHaggler2011', cls=<class 'negmas.gb.components.genius.acceptance.GACIAMHaggler2011'>, source='negmas', description='AC_IAMHaggler2011 acceptance strategy from Genius (ANAC2011).\n\nGP-smoothed estimate based acceptance. Similar to IAMHaggler2010\nwith improved estimation.\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n    maximum_aspiration: Target utility threshold (default 0.9).\n    accept_multiplier: Multiplier for acceptance comparison (default 1.02).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_IAMHaggler2011', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2011', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACIAMHaggler2012#9309b02c': ComponentInfo(key='GACIAMHaggler2012#9309b02c', short_name='GACIAMHaggler2012', full_type_name='negmas.gb.components.genius.acceptance.GACIAMHaggler2012', cls=<class 'negmas.gb.components.genius.acceptance.GACIAMHaggler2012'>, source='negmas', description='AC_IAMHaggler2012 acceptance strategy from Genius (ANAC2012).\n\nAdaptive threshold acceptance with multiplier-based comparison.\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n    accept_multiplier: Multiplier for acceptance (default 1.02).\n    maximum_aspiration: Maximum target utility (default 0.9).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2012.AC_IAMHaggler2012', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2012', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACInoxAgent#dc27fe97': ComponentInfo(key='GACInoxAgent#dc27fe97', short_name='GACInoxAgent', full_type_name='negmas.gb.components.genius.acceptance.GACInoxAgent', cls=<class 'negmas.gb.components.genius.acceptance.GACInoxAgent'>, source='negmas', description="AC_InoxAgent acceptance strategy from Genius (ANAC2013).\n\nScaling threshold acceptance. Breaks when reservation value is better,\naccepts when opponent's offer exceeds a time-dependent threshold.\n\nArgs:\n    reservation_value: Minimum acceptable utility (default 0.0).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2013.AC_InoxAgent", params={}, tags={'genius', 'ai-generated', 'anac2013', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACInoxAgentOneIssue#735e59cf': ComponentInfo(key='GACInoxAgentOneIssue#735e59cf', short_name='GACInoxAgentOneIssue', full_type_name='negmas.gb.components.genius.acceptance.GACInoxAgentOneIssue', cls=<class 'negmas.gb.components.genius.acceptance.GACInoxAgentOneIssue'>, source='negmas', description="AC_InoxAgent_OneIssue acceptance strategy from Genius (ANAC2013).\n\nSimplified InoxAgent for single-issue domains. Accepts when\nopponent's offer exceeds median utility.\n\nArgs:\n    reservation_value: Minimum acceptable utility (default 0.0).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2013.AC_InoxAgent_OneIssue", params={}, tags={'genius', 'ai-generated', 'anac2013', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACMAC#0c01ec89': ComponentInfo(key='GACMAC#0c01ec89', short_name='GACMAC', full_type_name='negmas.gb.components.genius.acceptance.GACMAC', cls=<class 'negmas.gb.components.genius.acceptance.GACMAC'>, source='negmas', description='AC_MAC acceptance strategy from Genius.\n\nMulti-acceptance condition testing. Combines multiple AC strategies\nand accepts if any of them would accept.\n\nThis is a simplified version that combines AC_CombiV4 and AC_CombiMaxInWindow\nwith default parameters.\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n    constant: Utility threshold (default 0.95).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_MAC', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'multi-attribute', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACNext#e2b47850': ComponentInfo(key='GACNext#e2b47850', short_name='GACNext', full_type_name='negmas.gb.components.genius.acceptance.GACNext', cls=<class 'negmas.gb.components.genius.acceptance.GACNext'>, source='negmas', description="AC_Next acceptance strategy from Genius.\n\nAccepts an offer if:\n    a * u(opponent_offer) + b >= u(my_next_offer)\n\nwhere:\n    - u(opponent_offer): Utility of the opponent's current offer\n    - u(my_next_offer): Utility of the offer we would make next\n    - a: Scaling factor (default 1.0)\n    - b: Offset factor (default 0.0)\n\nWith default parameters (a=1, b=0), this accepts if the opponent's offer\nis at least as good as what we would offer next.\n\nArgs:\n    offering_policy: The offering strategy used to determine my next offer.\n    a: Scaling factor for opponent's offer utility (default 1.0).\n    b: Offset added to scaled opponent utility (default 0.0).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_Next", params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'genius-translated', 'adaptive'}, extra={}, component_type='acceptance'), 'GACNiceTitForTat#8c9e73b9': ComponentInfo(key='GACNiceTitForTat#8c9e73b9', short_name='GACNiceTitForTat', full_type_name='negmas.gb.components.genius.acceptance.GACNiceTitForTat', cls=<class 'negmas.gb.components.genius.acceptance.GACNiceTitForTat'>, source='negmas', description='AC_NiceTitForTat acceptance strategy from Genius (ANAC2011).\n\nCooperative strategy based on opponent behavior. Uses AC_Next logic\ncombined with probabilistic acceptance near the deadline.\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_NiceTitForTat', params={}, tags={'tit-for-tat', 'genius', 'ai-generated', 'acceptance', 'boa', 'anac2011', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACNozomi#1cde5a22': ComponentInfo(key='GACNozomi#1cde5a22', short_name='GACNozomi', full_type_name='negmas.gb.components.genius.acceptance.GACNozomi', cls=<class 'negmas.gb.components.genius.acceptance.GACNozomi'>, source='negmas', description='AC_Nozomi acceptance strategy from Genius (ANAC2010).\n\nA sophisticated strategy that considers opponent modeling, time pressure,\nand evaluation gap between bids. Accepts based on multiple conditions\nthat change with time phases.\n\nArgs:\n    max_util_threshold: Threshold relative to max utility (default 0.95).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2010.AC_Nozomi', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'genius-translated', 'anac2010'}, extra={}, component_type='acceptance'), 'GACOMACagent#cace2125': ComponentInfo(key='GACOMACagent#cace2125', short_name='GACOMACagent', full_type_name='negmas.gb.components.genius.acceptance.GACOMACagent', cls=<class 'negmas.gb.components.genius.acceptance.GACOMACagent'>, source='negmas', description="AC_OMACagent acceptance strategy from Genius (ANAC2012).\n\nAccepts if we've made this bid before or if opponent's utility\nis at least as good as our planned bid.\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n    discount_threshold: Discount threshold for special behavior (default 0.845).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2012.AC_OMACagent", params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2012', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACPrevious#3090bc5a': ComponentInfo(key='GACPrevious#3090bc5a', short_name='GACPrevious', full_type_name='negmas.gb.components.genius.acceptance.GACPrevious', cls=<class 'negmas.gb.components.genius.acceptance.GACPrevious'>, source='negmas', description="AC_Previous acceptance strategy from Genius.\n\nAccepts an offer if:\n    a * u(opponent_offer) + b >= u(my_previous_offer)\n\nSimilar to AC_Next but compares against our previous offer instead of next.\n\nArgs:\n    a: Scaling factor for opponent's offer utility (default 1.0).\n    b: Offset added to scaled opponent utility (default 0.0).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_Previous", params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'genius-translated', 'adaptive'}, extra={}, component_type='acceptance'), 'GACTheFawkes#cf7f849e': ComponentInfo(key='GACTheFawkes#cf7f849e', short_name='GACTheFawkes', full_type_name='negmas.gb.components.genius.acceptance.GACTheFawkes', cls=<class 'negmas.gb.components.genius.acceptance.GACTheFawkes'>, source='negmas', description="AC_TheFawkes acceptance strategy from Genius (ANAC2013).\n\nACcombi = ACnext || (ACtime(T) & ACconst(MAXw)).\nAccepts when our bid is worse than opponent's, or near deadline\nwhen opponent's bid has maximum value in a window.\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2013.AC_TheFawkes", params={}, tags={'genius', 'ai-generated', 'anac2013', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACTheNegotiator#711bb93e': ComponentInfo(key='GACTheNegotiator#711bb93e', short_name='GACTheNegotiator', full_type_name='negmas.gb.components.genius.acceptance.GACTheNegotiator', cls=<class 'negmas.gb.components.genius.acceptance.GACTheNegotiator'>, source='negmas', description='AC_TheNegotiator acceptance strategy from Genius (ANAC2011).\n\nState machine with phases: hardball, conceding, and desperate.\nAcceptance threshold varies based on the current phase.\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_TheNegotiator', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2011', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACTheNegotiatorReloaded#d208e7be': ComponentInfo(key='GACTheNegotiatorReloaded#d208e7be', short_name='GACTheNegotiatorReloaded', full_type_name='negmas.gb.components.genius.acceptance.GACTheNegotiatorReloaded', cls=<class 'negmas.gb.components.genius.acceptance.GACTheNegotiatorReloaded'>, source='negmas', description='AC_TheNegotiatorReloaded acceptance strategy from Genius (ANAC2012).\n\nPhase-based acceptance with domain analysis. Uses AC_Next variant\ncombined with AC_MaxInWindow for panic phase.\n\nArgs:\n    offering_policy: The offering strategy to determine next bid.\n    a_next: Scaling factor for AC_next no discount (default 1.0).\n    b_next: Addition factor for AC_next no discount (default 0.0).\n    constant: Utility threshold above which to always accept (default 0.98).\n    panic_time: Time after which panic phase begins (default 0.99).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2012.AC_TheNegotiatorReloaded', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2012', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACTime#84cbc5ef': ComponentInfo(key='GACTime#84cbc5ef', short_name='GACTime', full_type_name='negmas.gb.components.genius.acceptance.GACTime', cls=<class 'negmas.gb.components.genius.acceptance.GACTime'>, source='negmas', description='AC_Time acceptance strategy from Genius.\n\nAccepts any offer after a certain time threshold has passed.\n\nArgs:\n    t: Time threshold (0 to 1). Accept any offer when time > t (default 0.99).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_Time', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'genius-translated', 'time-based'}, extra={}, component_type='acceptance'), 'GACTrue#75f98043': ComponentInfo(key='GACTrue#75f98043', short_name='GACTrue', full_type_name='negmas.gb.components.genius.acceptance.GACTrue', cls=<class 'negmas.gb.components.genius.acceptance.GACTrue'>, source='negmas', description='AC_True acceptance strategy from Genius.\n\nAlways accepts any offer. Useful for debugging and testing.\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_True', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'simple', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACUncertain#218e42ba': ComponentInfo(key='GACUncertain#218e42ba', short_name='GACUncertain', full_type_name='negmas.gb.components.genius.acceptance.GACUncertain', cls=<class 'negmas.gb.components.genius.acceptance.GACUncertain'>, source='negmas', description='AC_Uncertain acceptance strategy from Genius.\n\nHandles uncertainty profiles. Accepts if offer is in top 10% of bids\nor if utility is at least 90% of our last offer.\n\nArgs:\n    top_percentile: Top percentile to accept (default 0.1).\n    utility_ratio: Minimum ratio to our last offer (default 0.9).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.other.AC_Uncertain', params={}, tags={'genius', 'ai-generated', 'uncertainty', 'acceptance', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACValueModelAgent#88af9115': ComponentInfo(key='GACValueModelAgent#88af9115', short_name='GACValueModelAgent', full_type_name='negmas.gb.components.genius.acceptance.GACValueModelAgent', cls=<class 'negmas.gb.components.genius.acceptance.GACValueModelAgent'>, source='negmas', description="AC_ValueModelAgent acceptance strategy from Genius (ANAC2011).\n\nValue model based acceptance that tracks opponent's maximum utility\nand accepts based on various thresholds that change with time.\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_ValueModelAgent", params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'anac2011', 'gb', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACYushu#278e6ccf': ComponentInfo(key='GACYushu#278e6ccf', short_name='GACYushu', full_type_name='negmas.gb.components.genius.acceptance.GACYushu', cls=<class 'negmas.gb.components.genius.acceptance.GACYushu'>, source='negmas', description='AC_Yushu acceptance strategy from Genius (ANAC2010).\n\nTime-dependent threshold strategy. The target utility decreases from\na high value (0.95) towards a lower acceptable value (0.7) as time progresses.\n\nArgs:\n    initial_target: Initial target utility (default 0.95).\n    final_target: Final target utility at deadline (default 0.7).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2010.AC_Yushu', params={}, tags={'genius', 'ai-generated', 'acceptance', 'boa', 'gb', 'genius-translated', 'anac2010'}, extra={}, component_type='acceptance'), 'GAgentFSEGAOffering#8f3ada50': ComponentInfo(key='GAgentFSEGAOffering#8f3ada50', short_name='GAgentFSEGAOffering', full_type_name='negmas.gb.components.genius.offering.GAgentFSEGAOffering', cls=<class 'negmas.gb.components.genius.offering.GAgentFSEGAOffering'>, source='negmas', description='AgentFSEGA offering strategy from ANAC 2010.\n\nThis strategy uses a time-dependent utility threshold that decreases\nexponentially over time. It selects bids that maximize opponent utility\nwhile staying above the threshold.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2010.AgentFSEGA_Offering', params={}, tags={'genius', 'anac2010', 'ai-generated', 'offering', 'boa', 'gb', 'genius-translated', 'adaptive'}, extra={}, component_type='offering'), 'GAgentK2Offering#fb7335cf': ComponentInfo(key='GAgentK2Offering#fb7335cf', short_name='GAgentK2Offering', full_type_name='negmas.gb.components.genius.offering.GAgentK2Offering', cls=<class 'negmas.gb.components.genius.offering.GAgentK2Offering'>, source='negmas', description='AgentK2 offering strategy from ANAC 2011.\n\nEnhanced version of AgentK with improved opponent modeling.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2011.AgentK2_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'boa', 'anac2011', 'gb', 'genius-translated', 'adaptive'}, extra={}, component_type='offering'), 'GAgentKOffering#8d724b72': ComponentInfo(key='GAgentKOffering#8d724b72', short_name='GAgentKOffering', full_type_name='negmas.gb.components.genius.offering.GAgentKOffering', cls=<class 'negmas.gb.components.genius.offering.GAgentKOffering'>, source='negmas', description="AgentK offering strategy from ANAC 2010.\n\nThis strategy uses a time-dependent target utility that adapts based on\nthe opponent's behavior. It maintains a map of offered bids and selects\nbids above a dynamic target threshold.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2010.AgentK_Offering", params={}, tags={'genius', 'anac2010', 'ai-generated', 'offering', 'boa', 'gb', 'genius-translated', 'adaptive'}, extra={}, component_type='offering'), 'GAgentLGModel#ec0acfc0': ComponentInfo(key='GAgentLGModel#ec0acfc0', short_name='GAgentLGModel', full_type_name='negmas.gb.components.genius.models.GAgentLGModel', cls=<class 'negmas.gb.components.genius.models.GAgentLGModel'>, source='negmas', description='AgentLG opponent model.\n\nThis model uses learning-based estimation of opponent preferences.\n\nTranscompiled from: negotiator.boaframework.opponentmodel.AgentLGModel', params={}, tags={'genius', 'ai-generated', 'boa', 'anac2012', 'learning', 'gb', 'genius-translated', 'model'}, extra={}, component_type='model'), 'GAgentLGOffering#5fa3e178': ComponentInfo(key='GAgentLGOffering#5fa3e178', short_name='GAgentLGOffering', full_type_name='negmas.gb.components.genius.offering.GAgentLGOffering', cls=<class 'negmas.gb.components.genius.offering.GAgentLGOffering'>, source='negmas', description='AgentLG offering strategy from ANAC 2012.\n\nThis strategy uses learning-based concession.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2012.AgentLG_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'boa', 'anac2012', 'learning', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GAgentMROffering#9db32c9b': ComponentInfo(key='GAgentMROffering#9db32c9b', short_name='GAgentMROffering', full_type_name='negmas.gb.components.genius.offering.GAgentMROffering', cls=<class 'negmas.gb.components.genius.offering.GAgentMROffering'>, source='negmas', description='AgentMR offering strategy from ANAC 2012.\n\nThis strategy uses risk-based concession.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2012.AgentMR_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'boa', 'anac2012', 'gb', 'genius-translated', 'risk-based'}, extra={}, component_type='offering'), 'GAgentSmithOffering#b052e1d0': ComponentInfo(key='GAgentSmithOffering#b052e1d0', short_name='GAgentSmithOffering', full_type_name='negmas.gb.components.genius.offering.GAgentSmithOffering', cls=<class 'negmas.gb.components.genius.offering.GAgentSmithOffering'>, source='negmas', description='AgentSmith offering strategy from ANAC 2010.\n\nThis strategy offers bids based on a time-dependent concession,\nsimilar to Boulware but with specific parameters.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2010.AgentSmith_Offering', params={}, tags={'genius', 'anac2010', 'ai-generated', 'offering', 'boa', 'gb', 'genius-translated', 'time-based'}, extra={}, component_type='offering'), 'GAgentXFrequencyModel#3f637567': ComponentInfo(key='GAgentXFrequencyModel#3f637567', short_name='GAgentXFrequencyModel', full_type_name='negmas.gb.components.genius.models.GAgentXFrequencyModel', cls=<class 'negmas.gb.components.genius.models.GAgentXFrequencyModel'>, source='negmas', description='AgentX frequency-based opponent model from Genius.\n\nFrom AgentX (ANAC 2015). An advanced frequency model that uses both\nvalue frequencies and issue weight learning based on bid patterns.\n\nTracks issue weights by observing which issues change less frequently,\nand uses exponential smoothing for weight updates.\n\nArgs:\n    learning_rate: Learning rate for weight updates (default 0.25).\n    default_value: Default value for unseen issue values (default 1).\n\nTranscompiled from: negotiator.boaframework.opponentmodel.AgentXFrequencyModel', params={}, tags={'genius', 'learning', 'ai-generated', 'boa', 'frequency', 'gb', 'genius-translated', 'model'}, extra={}, component_type='model'), 'GBRAMAgent2Offering#39460690': ComponentInfo(key='GBRAMAgent2Offering#39460690', short_name='GBRAMAgent2Offering', full_type_name='negmas.gb.components.genius.offering.GBRAMAgent2Offering', cls=<class 'negmas.gb.components.genius.offering.GBRAMAgent2Offering'>, source='negmas', description='BRAMAgent2 offering strategy from ANAC 2012.\n\nEnhanced version of BRAMAgent with improved statistics tracking.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2012.BRAMAgent2_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'opponent-modeling', 'boa', 'anac2012', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GBRAMAgentOffering#5cf1d1af': ComponentInfo(key='GBRAMAgentOffering#5cf1d1af', short_name='GBRAMAgentOffering', full_type_name='negmas.gb.components.genius.offering.GBRAMAgentOffering', cls=<class 'negmas.gb.components.genius.offering.GBRAMAgentOffering'>, source='negmas', description='BRAMAgent offering strategy from ANAC 2011.\n\nThis strategy uses opponent modeling based on bid frequency statistics\nto create bids that are acceptable to both parties.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2011.BRAMAgent_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'opponent-modeling', 'boa', 'anac2011', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GBayesianModel#c9ccc823': ComponentInfo(key='GBayesianModel#c9ccc823', short_name='GBayesianModel', full_type_name='negmas.gb.components.genius.models.GBayesianModel', cls=<class 'negmas.gb.components.genius.models.GBayesianModel'>, source='negmas', description="Bayesian opponent model from Genius.\n\nUses Bayesian inference to update beliefs about opponent's utility function\nbased on their bids. Maintains probability distributions over possible\nopponent preferences and updates them using Bayes' rule.\n\nThis is a simplified version that assumes the opponent is rational and\nonly offers bids above some threshold.\n\nArgs:\n    n_hypotheses: Number of hypotheses to consider (default 10).\n    rationality: Assumed opponent rationality - higher values assume\n        opponent is more likely to make utility-maximizing bids (default 5.0).\n\nTranscompiled from: negotiator.boaframework.opponentmodel.BayesianModel", params={}, tags={'genius', 'ai-generated', 'bayesian', 'boa', 'learning', 'gb', 'genius-translated', 'model'}, extra={}, component_type='model'), 'GBoulwareOffering#8b4319af': ComponentInfo(key='GBoulwareOffering#8b4319af', short_name='GBoulwareOffering', full_type_name='negmas.gb.components.genius.offering.GBoulwareOffering', cls=<class 'negmas.gb.components.genius.offering.GBoulwareOffering'>, source='negmas', description='Boulware offering strategy - a time-dependent strategy with e < 1.\n\nConcedes slowly at first, then faster as deadline approaches.\nThis is a convenience wrapper around GTimeDependentOffering.\n\nArgs:\n    e: Concession exponent (default 0.2, typical Boulware value).\n    k: Offset constant (default 0).\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.other.TimeDependent_Offering with e < 1', params={}, tags={'genius', 'offering', 'ai-generated', 'boulware', 'boa', 'gb', 'genius-translated', 'time-based'}, extra={}, component_type='offering'), 'GCUHKAgentOffering#df21f21e': ComponentInfo(key='GCUHKAgentOffering#df21f21e', short_name='GCUHKAgentOffering', full_type_name='negmas.gb.components.genius.offering.GCUHKAgentOffering', cls=<class 'negmas.gb.components.genius.offering.GCUHKAgentOffering'>, source='negmas', description='CUHKAgent offering strategy from ANAC 2012.\n\nThis strategy uses sophisticated opponent modeling and adaptive concession.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2012.CUHKAgent_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'boa', 'anac2012', 'gb', 'genius-translated', 'adaptive'}, extra={}, component_type='offering'), 'GCUHKFrequencyModel#465592b2': ComponentInfo(key='GCUHKFrequencyModel#465592b2', short_name='GCUHKFrequencyModel', full_type_name='negmas.gb.components.genius.models.GCUHKFrequencyModel', cls=<class 'negmas.gb.components.genius.models.GCUHKFrequencyModel'>, source='negmas', description='CUHK Frequency-based opponent model.\n\nThis model tracks bid frequencies and uses them to estimate\nopponent preferences with specific adaptations from the CUHK agent.\n\nTranscompiled from: negotiator.boaframework.opponentmodel.CUHKFrequencyModelV2', params={}, tags={'boa', 'frequency', 'gb', 'genius-translated', 'genius', 'anac2012', 'ai-generated', 'learning', 'model'}, extra={}, component_type='model'), 'GChoosingAllBids#60bbba33': ComponentInfo(key='GChoosingAllBids#60bbba33', short_name='GChoosingAllBids', full_type_name='negmas.gb.components.genius.offering.GChoosingAllBids', cls=<class 'negmas.gb.components.genius.offering.GChoosingAllBids'>, source='negmas', description='ChoosingAllBids offering strategy from Genius.\n\nIterates through all possible bids in the domain, offering each one\nin sequence. Useful for exhaustive exploration or testing.\n\nWhen all bids have been offered, it restarts from the beginning.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.other.ChoosingAllBids', params={}, tags={'exhaustive', 'genius', 'offering', 'ai-generated', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GConcederOffering#c8eb9e6f': ComponentInfo(key='GConcederOffering#c8eb9e6f', short_name='GConcederOffering', full_type_name='negmas.gb.components.genius.offering.GConcederOffering', cls=<class 'negmas.gb.components.genius.offering.GConcederOffering'>, source='negmas', description='Conceder offering strategy - a time-dependent strategy with e > 1.\n\nConcedes quickly at first, then slows down as deadline approaches.\nThis is a convenience wrapper around GTimeDependentOffering.\n\nArgs:\n    e: Concession exponent (default 2.0, typical Conceder value).\n    k: Offset constant (default 0).\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.other.TimeDependent_Offering with e > 1', params={}, tags={'genius', 'conceder', 'ai-generated', 'offering', 'boa', 'gb', 'genius-translated', 'time-based'}, extra={}, component_type='offering'), 'GDefaultModel#ef700a74': ComponentInfo(key='GDefaultModel#ef700a74', short_name='GDefaultModel', full_type_name='negmas.gb.components.genius.models.GDefaultModel', cls=<class 'negmas.gb.components.genius.models.GDefaultModel'>, source='negmas', description="Default opponent model from Genius.\n\nA no-op model that doesn't learn from opponent behavior and assumes\nuniform preferences. Always returns 0.5 utility for any outcome.\n\nUseful as a baseline or placeholder when no opponent modeling is needed.\n\nTranscompiled from: negotiator.boaframework.opponentmodel.DefaultModel", params={}, tags={'genius', 'ai-generated', 'boa', 'gb', 'simple', 'genius-translated', 'model'}, extra={}, component_type='model'), 'GFSEGABayesianModel#ffa07ac7': ComponentInfo(key='GFSEGABayesianModel#ffa07ac7', short_name='GFSEGABayesianModel', full_type_name='negmas.gb.components.genius.models.GFSEGABayesianModel', cls=<class 'negmas.gb.components.genius.models.GFSEGABayesianModel'>, source='negmas', description='FSEGA Bayesian opponent model.\n\nThis model uses Bayesian inference to estimate opponent preferences,\nmaintaining hypotheses about issue weights and value utilities.\n\nTranscompiled from: negotiator.boaframework.opponentmodel.FSEGABayesianModel', params={}, tags={'bayesian', 'boa', 'gb', 'genius-translated', 'model', 'genius', 'ai-generated', 'learning', 'anac2010'}, extra={}, component_type='model'), 'GFawkesOffering#7979b596': ComponentInfo(key='GFawkesOffering#7979b596', short_name='GFawkesOffering', full_type_name='negmas.gb.components.genius.offering.GFawkesOffering', cls=<class 'negmas.gb.components.genius.offering.GFawkesOffering'>, source='negmas', description='TheFawkes offering strategy from ANAC 2013.\n\nThis strategy uses wavelet-based prediction for opponent modeling.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2013.Fawkes_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'prediction', 'anac2013', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GGahboninhoOffering#3671303b': ComponentInfo(key='GGahboninhoOffering#3671303b', short_name='GGahboninhoOffering', full_type_name='negmas.gb.components.genius.offering.GGahboninhoOffering', cls=<class 'negmas.gb.components.genius.offering.GGahboninhoOffering'>, source='negmas', description='Gahboninho offering strategy from ANAC 2011.\n\nThis strategy uses adaptive concession based on opponent behavior analysis.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2011.Gahboninho_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'boa', 'anac2011', 'gb', 'genius-translated', 'adaptive'}, extra={}, component_type='offering'), 'GHardHeadedFrequencyModel#92f0b7ed': ComponentInfo(key='GHardHeadedFrequencyModel#92f0b7ed', short_name='GHardHeadedFrequencyModel', full_type_name='negmas.gb.components.genius.models.GHardHeadedFrequencyModel', cls=<class 'negmas.gb.components.genius.models.GHardHeadedFrequencyModel'>, source='negmas', description="Hard-Headed Frequency-based opponent model from Genius.\n\nThis model estimates the opponent's utility function by tracking which\nissues remain unchanged between consecutive opponent bids. Issues that\ndon't change are assumed to be more important to the opponent.\n\nThe model works by:\n1. Tracking bid frequencies for each issue value\n2. When an issue value stays the same between consecutive bids,\n   increasing its weight (the opponent likely cares about that issue)\n3. Computing opponent utility as a weighted sum of issue value frequencies\n\nArgs:\n    learning_coef: Learning coefficient controlling how fast weights adapt.\n        Higher values mean faster adaptation (default 0.2).\n    learning_value_addition: Value added to unchanged issue weights (default 1).\n    default_value: Default value for unseen issue values (default 1).\n\nTranscompiled from: negotiator.boaframework.opponentmodel.HardHeadedFrequencyModel", params={}, tags={'genius', 'learning', 'ai-generated', 'boa', 'frequency', 'gb', 'genius-translated', 'model'}, extra={}, component_type='model'), 'GHardHeadedOffering#d0bc3667': ComponentInfo(key='GHardHeadedOffering#d0bc3667', short_name='GHardHeadedOffering', full_type_name='negmas.gb.components.genius.offering.GHardHeadedOffering', cls=<class 'negmas.gb.components.genius.offering.GHardHeadedOffering'>, source='negmas', description='HardHeaded offering strategy from ANAC 2011.\n\nThis strategy uses a conservative concession approach with queue-based\nbid selection. It maintains a queue of potential bids and selects\nbased on utility tolerance.\n\nArgs:\n    ka: Concession parameter (default 0.05).\n    e: Concession exponent (default 0.05).\n    min_utility: Minimum acceptable utility (default 0.585).\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2011.HardHeaded_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'boa', 'anac2011', 'conservative', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GHardlinerOffering#13790850': ComponentInfo(key='GHardlinerOffering#13790850', short_name='GHardlinerOffering', full_type_name='negmas.gb.components.genius.offering.GHardlinerOffering', cls=<class 'negmas.gb.components.genius.offering.GHardlinerOffering'>, source='negmas', description='Hardliner offering strategy - always offers the best outcome.\n\nNever concedes - always offers the maximum utility outcome.\nThis is equivalent to time-dependent with e = 0.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.other.TimeDependent_Offering with e = 0', params={}, tags={'genius', 'offering', 'ai-generated', 'hardliner', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GIAMCrazyHagglerOffering#18883578': ComponentInfo(key='GIAMCrazyHagglerOffering#18883578', short_name='GIAMCrazyHagglerOffering', full_type_name='negmas.gb.components.genius.offering.GIAMCrazyHagglerOffering', cls=<class 'negmas.gb.components.genius.offering.GIAMCrazyHagglerOffering'>, source='negmas', description="IAMCrazyHaggler offering strategy from ANAC 2010.\n\nThis strategy generates random bids with utility above a breakoff threshold.\nIt's a simple but effective hardliner strategy that never concedes below\na minimum utility level.\n\nArgs:\n    breakoff: Minimum utility threshold (default 0.9).\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2010.IAMCrazyHaggler_Offering", params={}, tags={'genius', 'offering', 'ai-generated', 'hardliner', 'boa', 'gb', 'genius-translated', 'anac2010'}, extra={}, component_type='offering'), 'GIAMHaggler2012Offering#912d7de2': ComponentInfo(key='GIAMHaggler2012Offering#912d7de2', short_name='GIAMHaggler2012Offering', full_type_name='negmas.gb.components.genius.offering.GIAMHaggler2012Offering', cls=<class 'negmas.gb.components.genius.offering.GIAMHaggler2012Offering'>, source='negmas', description='IAMHaggler2012 offering strategy from ANAC 2012.\n\nFurther refined version of IAMhaggler.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2012.IAMHaggler2012_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'boa', 'conservative', 'anac2012', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GIAMhaggler2010Offering#1588741e': ComponentInfo(key='GIAMhaggler2010Offering#1588741e', short_name='GIAMhaggler2010Offering', full_type_name='negmas.gb.components.genius.offering.GIAMhaggler2010Offering', cls=<class 'negmas.gb.components.genius.offering.GIAMhaggler2010Offering'>, source='negmas', description='IAMhaggler2010 offering strategy from ANAC 2010.\n\nThis strategy uses sophisticated time-dependent concession with\nopponent modeling considerations.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2010.IAMhaggler2010_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'boa', 'conservative', 'gb', 'genius-translated', 'anac2010'}, extra={}, component_type='offering'), 'GIAMhaggler2011Offering#c8713427': ComponentInfo(key='GIAMhaggler2011Offering#c8713427', short_name='GIAMhaggler2011Offering', full_type_name='negmas.gb.components.genius.offering.GIAMhaggler2011Offering', cls=<class 'negmas.gb.components.genius.offering.GIAMhaggler2011Offering'>, source='negmas', description='IAMhaggler2011 offering strategy from ANAC 2011.\n\nUpdated version of IAMhaggler with improved time management.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2011.IAMhaggler2011_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'boa', 'anac2011', 'conservative', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GIAMhagglerBayesianModel#93ff736d': ComponentInfo(key='GIAMhagglerBayesianModel#93ff736d', short_name='GIAMhagglerBayesianModel', full_type_name='negmas.gb.components.genius.models.GIAMhagglerBayesianModel', cls=<class 'negmas.gb.components.genius.models.GIAMhagglerBayesianModel'>, source='negmas', description='IAMhaggler Bayesian opponent model.\n\nThis model uses Bayesian inference to estimate opponent preferences\nwith specific adaptation for the IAMhaggler agent family.\n\nTranscompiled from: negotiator.boaframework.opponentmodel.IAMhagglerBayesianModel', params={}, tags={'genius', 'ai-generated', 'bayesian', 'boa', 'learning', 'gb', 'genius-translated', 'model'}, extra={}, component_type='model'), 'GInoxAgentModel#391d56cf': ComponentInfo(key='GInoxAgentModel#391d56cf', short_name='GInoxAgentModel', full_type_name='negmas.gb.components.genius.models.GInoxAgentModel', cls=<class 'negmas.gb.components.genius.models.GInoxAgentModel'>, source='negmas', description='InoxAgent opponent model.\n\nThis model uses adaptive preference estimation.\n\nTranscompiled from: negotiator.boaframework.opponentmodel.InoxAgent_OM', params={}, tags={'genius', 'ai-generated', 'anac2013', 'boa', 'learning', 'gb', 'genius-translated', 'model'}, extra={}, component_type='model'), 'GInoxAgentOffering#bbc737a6': ComponentInfo(key='GInoxAgentOffering#bbc737a6', short_name='GInoxAgentOffering', full_type_name='negmas.gb.components.genius.offering.GInoxAgentOffering', cls=<class 'negmas.gb.components.genius.offering.GInoxAgentOffering'>, source='negmas', description='InoxAgent offering strategy from ANAC 2013.\n\nThis strategy uses adaptive concession based on negotiation dynamics.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2013.InoxAgent_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'anac2013', 'boa', 'gb', 'genius-translated', 'adaptive'}, extra={}, component_type='offering'), 'GLinearOffering#c4c52fe7': ComponentInfo(key='GLinearOffering#c4c52fe7', short_name='GLinearOffering', full_type_name='negmas.gb.components.genius.offering.GLinearOffering', cls=<class 'negmas.gb.components.genius.offering.GLinearOffering'>, source='negmas', description='Linear offering strategy - a time-dependent strategy with e = 1.\n\nConcedes at a constant rate throughout negotiation.\nThis is a convenience wrapper around GTimeDependentOffering.\n\nArgs:\n    k: Offset constant (default 0).\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.other.TimeDependent_Offering with e = 1', params={}, tags={'genius', 'offering', 'ai-generated', 'boa', 'linear', 'gb', 'genius-translated', 'time-based'}, extra={}, component_type='offering'), 'GNashFrequencyModel#769ba08e': ComponentInfo(key='GNashFrequencyModel#769ba08e', short_name='GNashFrequencyModel', full_type_name='negmas.gb.components.genius.models.GNashFrequencyModel', cls=<class 'negmas.gb.components.genius.models.GNashFrequencyModel'>, source='negmas', description='Nash frequency-based opponent model from Genius.\n\nA frequency model that aims to estimate outcomes close to the Nash\nbargaining solution by combining opponent utility estimates with\nour own utility.\n\nUses frequency-based opponent modeling but biases toward Pareto-efficient\noutcomes by considering the product of utilities.\n\nArgs:\n    default_value: Default value for unseen issue values (default 1).\n\nTranscompiled from: negotiator.boaframework.opponentmodel.NashFrequencyModel', params={}, tags={'nash', 'boa', 'frequency', 'gb', 'genius-translated', 'genius', 'ai-generated', 'learning', 'model'}, extra={}, component_type='model'), 'GNiceTitForTatOffering#15e46315': ComponentInfo(key='GNiceTitForTatOffering#15e46315', short_name='GNiceTitForTatOffering', full_type_name='negmas.gb.components.genius.offering.GNiceTitForTatOffering', cls=<class 'negmas.gb.components.genius.offering.GNiceTitForTatOffering'>, source='negmas', description='NiceTitForTat offering strategy from ANAC 2011.\n\nThis strategy mirrors opponent concessions while maintaining a minimum\nacceptable utility level.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2011.NiceTitForTat_Offering', params={}, tags={'tit-for-tat', 'genius', 'offering', 'ai-generated', 'boa', 'anac2011', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GNozomiOffering#175ec425': ComponentInfo(key='GNozomiOffering#175ec425', short_name='GNozomiOffering', full_type_name='negmas.gb.components.genius.offering.GNozomiOffering', cls=<class 'negmas.gb.components.genius.offering.GNozomiOffering'>, source='negmas', description='Nozomi offering strategy from ANAC 2010.\n\nThis strategy uses adaptive concession based on opponent behavior\nand time pressure.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2010.Nozomi_Offering', params={}, tags={'genius', 'anac2010', 'ai-generated', 'offering', 'boa', 'gb', 'genius-translated', 'adaptive'}, extra={}, component_type='offering'), 'GOMACagentOffering#137be72b': ComponentInfo(key='GOMACagentOffering#137be72b', short_name='GOMACagentOffering', full_type_name='negmas.gb.components.genius.offering.GOMACagentOffering', cls=<class 'negmas.gb.components.genius.offering.GOMACagentOffering'>, source='negmas', description='OMACagent offering strategy from ANAC 2012.\n\nThis strategy uses prediction-based bidding with exponential moving average.\n\nArgs:\n    min_utility: Minimum utility threshold (default 0.59).\n    eu: Expected utility threshold (default 0.95).\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2012.OMACagent_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'prediction', 'boa', 'anac2012', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GOppositeModel#0de6a8a1': ComponentInfo(key='GOppositeModel#0de6a8a1', short_name='GOppositeModel', full_type_name='negmas.gb.components.genius.models.GOppositeModel', cls=<class 'negmas.gb.components.genius.models.GOppositeModel'>, source='negmas', description="Opposite opponent model from Genius.\n\nAssumes the opponent has exactly opposite preferences - what's good\nfor us is bad for them and vice versa. Returns 1 - our_utility.\n\nThis is a pessimistic assumption useful for competitive scenarios.\n\nTranscompiled from: negotiator.boaframework.opponentmodel.OppositeModel", params={}, tags={'genius', 'ai-generated', 'boa', 'gb', 'simple', 'genius-translated', 'model'}, extra={}, component_type='model'), 'GPerfectModel#d73bca0f': ComponentInfo(key='GPerfectModel#d73bca0f', short_name='GPerfectModel', full_type_name='negmas.gb.components.genius.models.GPerfectModel', cls=<class 'negmas.gb.components.genius.models.GPerfectModel'>, source='negmas', description="Perfect opponent model (for testing/debugging).\n\nThis model has access to the opponent's actual utility function.\nOnly useful in experimental settings where opponent preferences are known.\n\nTranscompiled from: negotiator.boaframework.opponentmodel.PerfectModel", params={}, tags={'testing', 'genius', 'ai-generated', 'boa', 'oracle', 'gb', 'genius-translated', 'model'}, extra={}, component_type='model'), 'GRandomOffering#4b5efac7': ComponentInfo(key='GRandomOffering#4b5efac7', short_name='GRandomOffering', full_type_name='negmas.gb.components.genius.offering.GRandomOffering', cls=<class 'negmas.gb.components.genius.offering.GRandomOffering'>, source='negmas', description='Random offering strategy from Genius.\n\nThis strategy offers random bids from the outcome space, completely\nignoring utility. Also known as "Zero Intelligence" or "Random Walker".\n\nThis is useful for:\n- Debugging and testing\n- Creating baseline comparisons\n- Simulating unpredictable opponents\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.other.Random_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'random', 'boa', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GScalableBayesianModel#cd0a80c5': ComponentInfo(key='GScalableBayesianModel#cd0a80c5', short_name='GScalableBayesianModel', full_type_name='negmas.gb.components.genius.models.GScalableBayesianModel', cls=<class 'negmas.gb.components.genius.models.GScalableBayesianModel'>, source='negmas', description='Scalable Bayesian opponent model from Genius.\n\nA Bayesian model optimized for large outcome spaces. Uses a more\nefficient representation that scales better with domain size.\n\nInstead of maintaining full hypothesis distributions, it tracks\nsufficient statistics and uses approximate inference.\n\nArgs:\n    learning_rate: Rate of belief updates (default 0.1).\n\nTranscompiled from: negotiator.boaframework.opponentmodel.ScalableBayesianModel', params={}, tags={'bayesian', 'boa', 'scalable', 'gb', 'genius-translated', 'genius', 'ai-generated', 'learning', 'model'}, extra={}, component_type='model'), 'GSmithFrequencyModel#1785a4cc': ComponentInfo(key='GSmithFrequencyModel#1785a4cc', short_name='GSmithFrequencyModel', full_type_name='negmas.gb.components.genius.models.GSmithFrequencyModel', cls=<class 'negmas.gb.components.genius.models.GSmithFrequencyModel'>, source='negmas', description='Smith frequency-based opponent model from Genius.\n\nFrom AgentSmith (ANAC 2010). Similar to HardHeadedFrequencyModel but\nwith a simpler weight update mechanism based purely on value frequencies.\n\nThe model tracks how often each value appears in opponent bids and\nassumes higher frequency = higher importance.\n\nArgs:\n    default_value: Default value for unseen issue values (default 1).\n\nTranscompiled from: negotiator.boaframework.opponentmodel.SmithFrequencyModel', params={}, tags={'genius', 'learning', 'ai-generated', 'boa', 'frequency', 'gb', 'genius-translated', 'model'}, extra={}, component_type='model'), 'GTheFawkesModel#9fca31f4': ComponentInfo(key='GTheFawkesModel#9fca31f4', short_name='GTheFawkesModel', full_type_name='negmas.gb.components.genius.models.GTheFawkesModel', cls=<class 'negmas.gb.components.genius.models.GTheFawkesModel'>, source='negmas', description='TheFawkes opponent model.\n\nThis model uses wavelet-based analysis for opponent preference estimation.\n\nTranscompiled from: negotiator.boaframework.opponentmodel.TheFawkes_OM', params={}, tags={'genius', 'ai-generated', 'anac2013', 'boa', 'learning', 'gb', 'genius-translated', 'model'}, extra={}, component_type='model'), 'GTheNegotiatorOffering#66e2be22': ComponentInfo(key='GTheNegotiatorOffering#66e2be22', short_name='GTheNegotiatorOffering', full_type_name='negmas.gb.components.genius.offering.GTheNegotiatorOffering', cls=<class 'negmas.gb.components.genius.offering.GTheNegotiatorOffering'>, source='negmas', description='TheNegotiator offering strategy from ANAC 2011.\n\nThis strategy uses time-dependent concession with adaptive parameters.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2011.TheNegotiator_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'piecewise', 'boa', 'anac2011', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GTheNegotiatorReloadedOffering#0cce2747': ComponentInfo(key='GTheNegotiatorReloadedOffering#0cce2747', short_name='GTheNegotiatorReloadedOffering', full_type_name='negmas.gb.components.genius.offering.GTheNegotiatorReloadedOffering', cls=<class 'negmas.gb.components.genius.offering.GTheNegotiatorReloadedOffering'>, source='negmas', description='TheNegotiatorReloaded offering strategy from ANAC 2012.\n\nEnhanced version of TheNegotiator with improved time management.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2012.TheNegotiatorReloaded_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'piecewise', 'boa', 'anac2012', 'gb', 'genius-translated'}, extra={}, component_type='offering'), 'GTimeDependentOffering#5334328c': ComponentInfo(key='GTimeDependentOffering#5334328c', short_name='GTimeDependentOffering', full_type_name='negmas.gb.components.genius.offering.GTimeDependentOffering', cls=<class 'negmas.gb.components.genius.offering.GTimeDependentOffering'>, source='negmas', description='Time-dependent offering strategy from Genius.\n\nThis strategy offers bids based on a time-dependent target utility curve.\nThe curve is controlled by the concession exponent `e`:\n- e = 0: Hardliner (never concedes)\n- e < 1: Boulware (concedes slowly, faster near deadline)\n- e = 1: Linear\n- e > 1: Conceder (concedes quickly at start)\n\nThe target utility at time t is computed as:\n    f(t) = k + (1 - k) * t^(1/e)\n    target(t) = Pmin + (Pmax - Pmin) * (1 - f(t))\n\nwhere:\n    - k: Offset constant (default 0)\n    - e: Concession exponent (default 0.2 for Boulware)\n    - Pmin: Minimum utility (reserved value)\n    - Pmax: Maximum utility (best outcome utility)\n\nArgs:\n    e: Concession exponent. Controls the shape of the concession curve.\n    k: Offset constant for the time function (default 0).\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.other.TimeDependent_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'boa', 'gb', 'genius-translated', 'time-based'}, extra={}, component_type='offering'), 'GUniformModel#9db9b60b': ComponentInfo(key='GUniformModel#9db9b60b', short_name='GUniformModel', full_type_name='negmas.gb.components.genius.models.GUniformModel', cls=<class 'negmas.gb.components.genius.models.GUniformModel'>, source='negmas', description='Uniform opponent model from Genius.\n\nAssumes the opponent values all outcomes equally - returns uniform\nrandom utility values. Each outcome gets a consistent random value.\n\nTranscompiled from: negotiator.boaframework.opponentmodel.UniformModel', params={}, tags={'genius', 'ai-generated', 'boa', 'gb', 'simple', 'genius-translated', 'model'}, extra={}, component_type='model'), 'GValueModelAgentOffering#33835c3c': ComponentInfo(key='GValueModelAgentOffering#33835c3c', short_name='GValueModelAgentOffering', full_type_name='negmas.gb.components.genius.offering.GValueModelAgentOffering', cls=<class 'negmas.gb.components.genius.offering.GValueModelAgentOffering'>, source='negmas', description='ValueModelAgent offering strategy from ANAC 2011.\n\nThis strategy uses value modeling to predict opponent preferences.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2011.ValueModelAgent_Offering', params={}, tags={'genius', 'offering', 'ai-generated', 'boa', 'anac2011', 'gb', 'value-modeling', 'genius-translated'}, extra={}, component_type='offering'), 'GWorstModel#85293d2b': ComponentInfo(key='GWorstModel#85293d2b', short_name='GWorstModel', full_type_name='negmas.gb.components.genius.models.GWorstModel', cls=<class 'negmas.gb.components.genius.models.GWorstModel'>, source='negmas', description='Worst-case opponent model.\n\nThis model assumes the opponent has opposite preferences to ours.\n\nTranscompiled from: negotiator.boaframework.opponentmodel.WorstModel', params={}, tags={'genius', 'pessimistic', 'ai-generated', 'boa', 'gb', 'simple', 'genius-translated', 'model'}, extra={}, component_type='model'), 'GYushuOffering#39f39bd0': ComponentInfo(key='GYushuOffering#39f39bd0', short_name='GYushuOffering', full_type_name='negmas.gb.components.genius.offering.GYushuOffering', cls=<class 'negmas.gb.components.genius.offering.GYushuOffering'>, source='negmas', description='Yushu offering strategy from ANAC 2010.\n\nThis strategy uses a sigmoid-like concession curve.\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2010.Yushu_Offering', params={}, tags={'genius', 'anac2010', 'ai-generated', 'offering', 'boa', 'gb', 'genius-translated', 'sigmoid'}, extra={}, component_type='offering'), 'NoneOfferingPolicy#de7896df': ComponentInfo(key='NoneOfferingPolicy#de7896df', short_name='NoneOfferingPolicy', full_type_name='negmas.gb.components.offering.NoneOfferingPolicy', cls=<class 'negmas.gb.components.offering.NoneOfferingPolicy'>, source='negmas', description='Always offers `None` which means it never gets an agreement.', params={}, tags={'sao', 'builtin', 'offering', 'simple'}, extra={}, component_type='offering'), 'OfferBest#14519870': ComponentInfo(key='OfferBest#14519870', short_name='OfferBest', full_type_name='negmas.gb.components.offering.OfferBest', cls=<class 'negmas.gb.components.offering.OfferBest'>, source='negmas', description='Offers Only the best outcome.\n\nRemarks:\n    - You can pass the  best outcome if you know it as `best` otherwise it will find it.', params={}, tags={'sao', 'builtin', 'offering', 'optimal'}, extra={}, component_type='offering'), 'OfferTop#03619148': ComponentInfo(key='OfferTop#03619148', short_name='OfferTop', full_type_name='negmas.gb.components.offering.OfferTop', cls=<class 'negmas.gb.components.offering.OfferTop'>, source='negmas', description='Offers outcomes that are in the given top fraction or top `k`. If neither is given it reverts to only offering the best outcome\n\nRemarks:\n    - The outcome-space is always discretized and the constraints `fraction` and `k` are applied to the discretized space', params={}, tags={'sao', 'builtin', 'offering', 'optimal'}, extra={}, component_type='offering'), 'RandomAcceptancePolicy#9b48fbc4': ComponentInfo(key='RandomAcceptancePolicy#9b48fbc4', short_name='RandomAcceptancePolicy', full_type_name='negmas.gb.components.acceptance.RandomAcceptancePolicy', cls=<class 'negmas.gb.components.acceptance.RandomAcceptancePolicy'>, source='negmas', description='Responds randomly with configurable probabilities for accept, reject, end, or no response.', params={}, tags={'sao', 'builtin', 'acceptance', 'random'}, extra={}, component_type='acceptance'), 'RandomOfferingPolicy#3d0ba5f3': ComponentInfo(key='RandomOfferingPolicy#3d0ba5f3', short_name='RandomOfferingPolicy', full_type_name='negmas.gb.components.offering.RandomOfferingPolicy', cls=<class 'negmas.gb.components.offering.RandomOfferingPolicy'>, source='negmas', description='Offers random outcomes from the negotiation outcome space.', params={}, tags={'sao', 'builtin', 'offering', 'random'}, extra={}, component_type='offering'), 'RejectAlways#87f7c6c9': ComponentInfo(key='RejectAlways#87f7c6c9', short_name='RejectAlways', full_type_name='negmas.gb.components.acceptance.RejectAlways', cls=<class 'negmas.gb.components.acceptance.RejectAlways'>, source='negmas', description='Rejects everything', params={}, tags={'sao', 'builtin', 'acceptance', 'simple'}, extra={}, component_type='acceptance'), 'TimeBasedOfferingPolicy#66d5eaac': ComponentInfo(key='TimeBasedOfferingPolicy#66d5eaac', short_name='TimeBasedOfferingPolicy', full_type_name='negmas.gb.components.offering.TimeBasedOfferingPolicy', cls=<class 'negmas.gb.components.offering.TimeBasedOfferingPolicy'>, source='negmas', description='TimeBasedOffering policy implementation.', params={}, tags={'sao', 'builtin', 'offering', 'time-based'}, extra={}, component_type='offering'), 'ZeroSumModel#2d6fcc67': ComponentInfo(key='ZeroSumModel#2d6fcc67', short_name='ZeroSumModel', full_type_name='negmas.sao.components.models.ufun.ZeroSumModel', cls=<class 'negmas.sao.components.models.ufun.ZeroSumModel'>, source='negmas', description='Assumes a zero-sum negotiation (i.e. $u_o$ = $-u_s$ )\n\nRemarks:\n\n    - Because some negotiators do not work well with negative ufun values, we return (max - u(w)) instead of (- u(w))', params={}, tags={'sao', 'builtin', 'zero-sum', 'model'}, extra={}, component_type='model')}

The global component registry.

negmas.registry.get_registered_class(name: str, registry: Registry[MechanismInfo] | Registry[NegotiatorInfo] | Registry[ComponentInfo]) → type | None

Get a registered class by name from a registry.

Parameters:

• name – The short name or full type name.

• registry – The registry to search.

Returns:

The class, or None if not found.

negmas.registry.load_registry(path: str | Path | None = None, *, include_mechanisms: bool = True, include_negotiators: bool = True, include_components: bool = True, include_scenarios: bool = True, clear_existing: bool = False) → dict[str, int]

Load registries from a folder.

This function loads previously saved registries from JSON files and adds them to the global registries.

Note: Class registrations require that the classes are importable. If a class cannot be imported, that registration is skipped with a warning.

Parameters:

• path – The folder to load from. Defaults to ~/negmas/registry.

• include_mechanisms – Whether to load the mechanism registry.

• include_negotiators – Whether to load the negotiator registry.

• include_components – Whether to load the component registry.

• include_scenarios – Whether to load the scenario registry.

• clear_existing – If True, clear existing registrations before loading.

Returns:

{‘mechanisms’: N, ‘negotiators’: N, ‘components’: N, ‘scenarios’: N}

Return type:

A dictionary with counts of loaded items

Raises:

FileNotFoundError – If the path does not exist.

Example

# Load from default location counts = load_registry() print(f”Loaded {counts[‘negotiators’]} negotiators”)

# Load from custom location, replacing existing load_registry(“/path/to/my/registry”, clear_existing=True)

# Load only scenarios load_registry(

include_mechanisms=False, include_negotiators=False, include_components=False,

)

negmas.registry.mechanism_registry: Registry[MechanismInfo] = {'HillClimbingSTMechanism#76f12133': MechanismInfo(key='HillClimbingSTMechanism#76f12133', short_name='HillClimbingSTMechanism', full_type_name='negmas.st.HillClimbingSTMechanism', cls=<class 'negmas.st.HillClimbingSTMechanism'>, source='negmas', description='A single text mechanism that use hill climbing\n\nArgs:\n    *args: positional arguments to be passed to the base Mechanism\n    **kwargs: keyword arguments to be passed to the base Mechanism', params={}, tags={'builtin', 'requires-deadline', 'st'}, extra={}), 'ParallelGBMechanism#13c0354d': MechanismInfo(key='ParallelGBMechanism#13c0354d', short_name='ParallelGBMechanism', full_type_name='negmas.gb.mechanisms.base.ParallelGBMechanism', cls=<class 'negmas.gb.mechanisms.base.ParallelGBMechanism'>, source='negmas', description='ParallelGB mechanism.', params={}, tags={'builtin', 'respond', 'requires-deadline', 'gb', 'propose'}, extra={}), 'SAOMechanism#513e5252': MechanismInfo(key='SAOMechanism#513e5252', short_name='SAOMechanism', full_type_name='negmas.sao.mechanism.SAOMechanism', cls=<class 'negmas.sao.mechanism.SAOMechanism'>, source='negmas', description="A generalized Stacked Alternating Offers Protocol mechanism.\n\nThis mechanism extends the classic SAO protocol with several advanced features:\n\n- **Dynamic Entry/Exit**: Negotiators can join after the negotiation starts\n  (``dynamic_entry=True``) and can leave gracefully using ``ResponseType.LEAVE``\n  without forcing the negotiation to end (``allow_negotiators_to_leave=True``).\n\n- **Per-Negotiator Limits**: Each negotiator can have individual time and step\n  limits, enabling asymmetric negotiation scenarios.\n\n- **Text-Based Communication**: Negotiators can send messages or explanations\n  alongside offers using the ``data`` field and can even send messages that do\n  not contain any offers as long as they include some text or data\n  (``allow_none_with_data=True``).\n\n- **Flexible Response Types**: Beyond ACCEPT/REJECT/END, negotiators can WAIT\n  (pause their turn) or LEAVE (exit gracefully).\n\n- **Callbacks**: Negotiators receive notifications when others join\n  (``on_negotiator_entered``) or leave (``on_negotiator_left``) and on the most\n  important events including partner offers, rounds start and end, etc.\n\nArgs:\n\n    outcome_space: The negotiation agenda\n    issues: A list of issues defining the outcome-space of the negotiation\n    outcomes: A list of outcomes defining the outcome-space of the negotiation\n    n_steps: The maximum number of negotiation rounds (see `time_limit` )\n    time_limit: The maximum wall-time allowed for the negotiation (see `n_steps`)\n    step_time_limit: The maximum wall-time allowed for a single negotiation round.\n    max_n_agents: The maximum number of negotiators allowed to join the negotiation.\n    dynamic_entry: Whether it is allowed for negotiators to join the negotiation after it starts\n    cache_outcomes: If true, the mechanism will catch `outcomes` and a discrete version (`discrete_outcomes`) that\n                    can be accessed by any negotiator through their NMIs.\n    max_cardinality: Maximum number or outcomes to use when discretizing the outcome-space\n    annotation: A key-value mapping to keep around. Accessible through the NMI but not used by the mechanism.\n    end_on_no_response: End the negotiation if any negotiator returns NO_RESPONSE from `respond`/`counter` or returns\n                        REJECT_OFFER then refuses to give an offer (by returning `None` from `proposee/`counter`).\n    enable_callbacks: Enable callbacks like on_round_start, etc. Note that on_negotiation_end is always received\n                      by the negotiators no matter what is the setting for this parameter.\n    check_offers: If true, offers are checked to see if they are valid for the negotiation\n                  outcome-space and if not the offer is considered None which is the same as\n                  refusing to offer (NO_RESPONSE).\n    enforce_issue_types: If True, the type of each issue is enforced depending on the value of `cast_offers`\n    cast_offers: If true, each issue value is cast using the issue's type otherwise an incorrect type will be considered an invalid offer. See `check_offers`. Only\n                 used if `enforce_issue_types`\n    ignore_negotiator_exceptions: just silently ignore negotiator exceptions and consider them no-responses.\n    offering_is_accepting: Offering an outcome implies accepting it. If not, the agent who proposed an offer will\n                           be asked to respond to it after all other agents.\n    allow_none_with_data: If True (default), a negotiator can respond with REJECT_OFFER and outcome=None\n                          as long as there is associated data (e.g., text). This allows negotiators to\n                          send messages or explanations without making a concrete offer. The negotiation\n                          will continue rather than breaking.\n    allow_negotiators_to_leave: If True (default), a LEAVE response removes the negotiator but remaining\n                       negotiators continue if 2+ remain. If fewer than 2 remain after leaving, the\n                       negotiation ends unless ``dynamic_entry=True`` (allowing new negotiators to join).\n                       If False, LEAVE is treated exactly like END_NEGOTIATION (breaks the negotiation).\n    sync_calls: If given, calls to negotiators will be synchronized. This will not enforce timeouts on\n                single calls which means that a negotiator in an infinite loop will hog the CPU. By default\n                calls are done using a different thread that is killed when the timeout passes. This may, but\n                is not guaranteed to, resolve this issue at the expense of slower negotiations and harder debugging\n    name: Name of the mechanisms\n    **kwargs: Extra parameters passed directly to the `Mechanism` constructor\n\nRemarks:\n\n    - One and only one of `outcome_space`, `issues`, `outcomes` can be given\n    - If both `n_steps` and `time_limit` are passed, the negotiation ends when either of the limits is reached.\n    - Negotiations may take longer than `time_limit` because negotiators are not interrupted while they are\n      executing their `respond` or `propose` methods.\n\nEvents:\n\n    - negotiator_exception: Data=(negotiator, exception) raised whenever a negotiator raises an exception if\n      ignore_negotiator_exceptions is set to True.", params={}, tags={'builtin', 'respond', 'sao', 'requires-deadline', 'propose'}, extra={}), 'SerialGBMechanism#880785da': MechanismInfo(key='SerialGBMechanism#880785da', short_name='SerialGBMechanism', full_type_name='negmas.gb.mechanisms.base.SerialGBMechanism', cls=<class 'negmas.gb.mechanisms.base.SerialGBMechanism'>, source='negmas', description='SerialGB mechanism.', params={}, tags={'builtin', 'respond', 'requires-deadline', 'gb', 'propose'}, extra={}), 'SerialTAUMechanism#a7f2c297': MechanismInfo(key='SerialTAUMechanism#a7f2c297', short_name='SerialTAUMechanism', full_type_name='negmas.gb.mechanisms.tauserial.SerialTAUMechanism', cls=<class 'negmas.gb.mechanisms.tauserial.SerialTAUMechanism'>, source='negmas', description='Implements the TAU protocol using the SerialGBMechanism construct in NegMAS', params={}, tags={'builtin', 'respond', 'gb', 'propose', 'tau'}, extra={}), 'TAUMechanism#cb0d0530': MechanismInfo(key='TAUMechanism#cb0d0530', short_name='TAUMechanism', full_type_name='negmas.gb.mechanisms.tau.TAUMechanism', cls=<class 'negmas.gb.mechanisms.tau.TAUMechanism'>, source='negmas', description='TAU (Threaded Acceptance with Unanimous agreement) mechanism.\n\nAn Outcome-Perfect Negotiation Protocol that guarantees finding an agreement\nif one exists within the declared acceptable outcomes of all negotiators.\nTAU allows agents to repeat offers, but once an agent starts repeating,\nit is committed to that offer.\n\nReferences:\n    Mohammad, Y. (2023). Generalized Bargaining Protocols.\n    In: Australasian Joint Conference on Artificial Intelligence (AI 2023).\n    Springer. https://doi.org/10.1007/978-981-99-8391-9_37\n\n    Mohammad, Y. (2025). Tackling the Protocol Problem in Automated Negotiation.\n    In: Proceedings of the 24th International Conference on\n    Autonomous Agents and Multi-Agent Systems (AAMAS 2025).', params={}, tags={'builtin', 'respond', 'gb', 'propose', 'tau'}, extra={}), 'VetoSTMechanism#8dc7f954': MechanismInfo(key='VetoSTMechanism#8dc7f954', short_name='VetoSTMechanism', full_type_name='negmas.st.VetoSTMechanism', cls=<class 'negmas.st.VetoSTMechanism'>, source='negmas', description='Base class for all single text mechanisms\n\nArgs:\n    *args: positional arguments to be passed to the base Mechanism\n    **kwargs: keyword arguments to be passed to the base Mechanism\n    initial_outcome: initial outcome. If None, it will be selected by `next_outcome` which by default will choose it\n                     randomly.\n    initial_responses: Initial set of responses.\n\nRemarks:\n\n    - initial_responses is only of value when the number of negotiators that will join the negotiation is less then\n      or equal to its length. By default it is not used for anything. Nevertheless, it is here because\n      `next_outcome` may decide to use it with the `initial_outcome`', params={}, tags={'builtin', 'requires-deadline', 'st'}, extra={})}

The gloabal mechanism registry.

negmas.registry.negotiator_registry: Registry[NegotiatorInfo] = {'ABMPAgent2#2e9a390f': NegotiatorInfo(key='ABMPAgent2#2e9a390f', short_name='ABMPAgent2', full_type_name='negmas.genius.gnegotiators.basic.ABMPAgent2', cls=<class 'negmas.genius.gnegotiators.basic.ABMPAgent2'>, source='negmas', description='ABMP (Automated Bilateral Multi-issue Protocol) Agent v2.\n\nUses the ABMP negotiation protocol which combines time-dependent concession\nwith similarity-based opponent modeling. Makes offers based on a target\nutility that decreases over time while trying to maximize joint utility.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n\nReferences:\n    Jonker, C. M., & Treur, J. (2001). An Agent Architecture for\n    Multi-Attribute Negotiation. IJCAI.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'AI2014Group2#65b40ed2': NegotiatorInfo(key='AI2014Group2#65b40ed2', short_name='AI2014Group2', full_type_name='negmas.genius.gnegotiators.others.AI2014Group2', cls=<class 'negmas.genius.gnegotiators.others.AI2014Group2'>, source='negmas', description="TU Delft AI 2014 Group 2 negotiation agent.\n\nStudent project agent from TU Delft's Artificial Intelligence course (2014).\nImplements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Agent33#9d8429b6': NegotiatorInfo(key='Agent33#9d8429b6', short_name='Agent33', full_type_name='negmas.genius.gnegotiators.y2018.Agent33', cls=<class 'negmas.genius.gnegotiators.y2018.Agent33'>, source='negmas', description="Agent33 negotiation agent.\n\n**ANAC 2018 competitor.**\n\nModular agent with separate components for statistics, bid search, history\ntracking, and strategy. Tracks rejected and agreed values per opponent.\n\n**Offering Strategy:**\n\n    - Uses time-dependent threshold from NegoStrategy component\n    - BidSearch generates bids above threshold considering opponent preferences\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent's bid utility exceeds current threshold\n    - Threshold decreases over time\n\n**Opponent Modeling:**\n\n    Tracks frequency of values rejected/agreed by each opponent via NegoStats.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.", params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'Agent36#b87883aa': NegotiatorInfo(key='Agent36#b87883aa', short_name='Agent36', full_type_name='negmas.genius.gnegotiators.y2018.Agent36', cls=<class 'negmas.genius.gnegotiators.y2018.Agent36'>, source='negmas', description='Agent36 (MengWan) negotiation agent.\n\n**ANAC 2018 competitor.**\n\nTracks opponent preferences via frequency maps and finds mutual issues\nbetween opponents. Stores commonly accepted bids across sessions.\n\n**Offering Strategy:**\n\n    - Generates bids above time-dependent threshold\n    - Threshold: 0.8 initially, 0.75 at t>0.95, 0.7 at t>0.98\n\n**Acceptance Strategy:**\n\n    - Accepts if utility exceeds current threshold\n    - More permissive in final negotiation stages\n\n**Opponent Modeling:**\n\n    Frequency-based tracking of opponent value preferences to identify\n    mutually beneficial issues.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'AgentBuyog#0d6a8cf9': NegotiatorInfo(key='AgentBuyog#0d6a8cf9', short_name='AgentBuyog', full_type_name='negmas.genius.gnegotiators.y2015.AgentBuyog', cls=<class 'negmas.genius.gnegotiators.y2015.AgentBuyog'>, source='negmas', description="AgentBuyog negotiation agent.\n\n**ANAC 2015 Individual Utility Category Runner-up**.\n\nAgentBuyog estimates the opponent's concession function using regression\nanalysis and uses this to determine optimal acceptance thresholds. It\nalso estimates opponent preferences to find bids near the Kalai point\n(social welfare maximum).\n\n**Offering Strategy:**\n    Selects bids based on domain competitiveness and opponent difficulty:\n\n    1. Calculates acceptance threshold based on estimated opponent\n       difficulty and time-based concession:\n\n       threshold = minPoint + (1 - minPoint) * (1 - t^1.8)\n\n    2. Searches for bids at or above threshold that are closest to\n       the estimated Kalai point (maximizing social welfare)\n    3. If common bids exist (offered by multiple opponents), prefers\n       those with highest utility\n\n    Near deadline (remaining rounds <= 3), threshold is halved.\n\n**Acceptance Strategy:**\n    Multi-criteria acceptance based on:\n\n    - Most recent offer utility vs. threshold\n    - Best agreeable bid utility (common to both opponents)\n    - Generated bid utility\n\n    Accepts if opponent's offer exceeds all other options and the\n    acceptance threshold, especially when near deadline.\n\n**Opponent Modeling:**\n    Sophisticated multi-component model:\n\n    - **Concession estimation**: Uses weighted regression to fit\n      exponential concession function exp(alpha) * t^beta to opponent\n      bid utilities over time\n    - **Leniency calculation**: Derived from slope of estimated\n      concession curve, adjusted by a leniency factor\n    - **Preference estimation**: Frequency-based issue weight and\n      value estimation, normalized after each update\n    - **Kalai point estimation**: Finds social welfare maximum\n      using estimated opponent preferences\n    - **Agent difficulty**: Combined metric of leniency and domain\n      competitiveness to assess how hard to negotiate with\n\nReferences:\n    Fujita, K., Aydogan, R., Baarslag, T., Hindriks, K., Ito, T., &\n    Jonker, C. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). In Fujita, K., et al. Modern Approaches to Agent-based\n    Complex Automated Negotiation. Studies in Computational Intelligence,\n    vol 674. Springer, Cham.", params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'AgentF#40a3be82': NegotiatorInfo(key='AgentF#40a3be82', short_name='AgentF', full_type_name='negmas.genius.gnegotiators.y2017.AgentF', cls=<class 'negmas.genius.gnegotiators.y2017.AgentF'>, source='negmas', description='AgentF negotiation agent.\n\n**ANAC 2017**.\n\nAgentF uses a modular architecture with negotiationInfo, bidSearch, and\nnegotiationStrategy components. It leverages persistent data from past\nnegotiations to build a "PBList" (popular bids from previous agreements).\n\n**Offering Strategy:**\n\n    - Uses time-scaled threshold via negotiationStrategy.getThreshold(time)\n    - Searches for bids above the threshold, preferring those in PBList\n    - In final phase, traverses a "CList" of candidate bids with concession\n    - Tracks supporter count in multilateral settings\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent\'s bid utility exceeds current threshold\n    - More aggressive acceptance in final negotiation phase\n\n**Opponent Modeling:**\n\n    - Builds PBList from past agreements across negotiations\n    - Uses persistent data to remember successful bids\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'AgentFSEGA#14f08b37': NegotiatorInfo(key='AgentFSEGA#14f08b37', short_name='AgentFSEGA', full_type_name='negmas.genius.gnegotiators.y2010.AgentFSEGA', cls=<class 'negmas.genius.gnegotiators.y2010.AgentFSEGA'>, source='negmas', description="AgentFSEGA negotiation agent.\n\n**ANAC 2010 Finalist**.\n\nAgentFSEGA (developed by West University of Timisoara, Romania) uses Bayesian\nopponent modeling and time-dependent concession with three behavioral phases.\n\n**Offering Strategy:**\n\n    - Starts with maximum utility bid\n    - Maintains sorted list of bids above a minimum utility threshold (0.5)\n    - Time-dependent behavior with three phases:\n        - Phase 0 (t < 0.85): Conservative, stays within small sigma of best bid\n        - Phase 1 (0.85 ≤ t < 0.95): Moderate concession\n        - Phase 2 (t ≥ 0.95): More aggressive concession toward deadline\n    - Selects bids that maximize estimated opponent utility within acceptable range\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent's bid utility × 1.03 ≥ own last bid's utility\n    - Accepts if opponent's bid utility > planned next bid's utility\n    - Accepts opponent's first bid if it equals maximum possible utility\n\n**Opponent Modeling:**\n\n    Bayesian learning approach:\n\n    - Uses Bayesian opponent model to estimate opponent preferences\n    - Updates beliefs based on opponent's bid history\n    - Selects bids that are good for opponent among acceptable options\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Baarslag, T., Hindriks, K., Hendrikx, M., Dirkzwager, A., & Jonker, C.M. (2014).\n    Decoupling Negotiating Agents to Explore the Space of Negotiation Strategies.\n    In Novel Insights in Agent-based Complex Automated Negotiation.\n    Studies in Computational Intelligence, vol 535. Springer.", params={}, tags={'genius', 'anac-2010', 'respond', 'propose', 'anac'}, extra={}), 'AgentGG#51777cda': NegotiatorInfo(key='AgentGG#51777cda', short_name='AgentGG', full_type_name='negmas.genius.gnegotiators.y2019.AgentGG', cls=<class 'negmas.genius.gnegotiators.y2019.AgentGG'>, source='negmas', description="AgentGG negotiation agent.\n\n**ANAC 2019 Winner** (Individual Utility category).\n\nAgentGG (developed by Shaobo Xu) uses importance maps (a frequentist\napproach) to estimate both self and opponent preferences, focusing on\nbid importance rather than raw utility values.\n\n**Offering Strategy:**\n\n    - Time-based concession with importance thresholds\n    - Early phase (t < 0.2): random bid selection within threshold\n    - Middle phase: selects bids maximizing estimated opponent importance\n    - Thresholds decrease over time based on estimated Nash point\n    - Uses importance maps instead of utility for bid evaluation\n\n**Acceptance Strategy:**\n\n    - Accepts if received bid's importance ratio exceeds current threshold\n    - Near deadline (t >= 0.9989): accepts if importance exceeds\n      reservation + 0.2\n    - Thresholds adapt based on estimated Nash point\n\n**Opponent Modeling:**\n    Frequentist importance maps that estimate:\n\n    - Self preferences from own utility function analysis\n    - Opponent preferences from their bidding patterns\n    - Uses estimated opponent importance to select favorable bids\n    - Updates opponent model during early negotiation (t < 0.3)\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of the Automated\n    Negotiating Agents Competition (ANAC) 2019. In Multi-Agent Systems and\n    Agreement Technologies. EUMAS AT 2020. Lecture Notes in Computer Science,\n    vol 12520. Springer, Cham.", params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'AgentGP#9d16ac40': NegotiatorInfo(key='AgentGP#9d16ac40', short_name='AgentGP', full_type_name='negmas.genius.gnegotiators.y2019.AgentGP', cls=<class 'negmas.genius.gnegotiators.y2019.AgentGP'>, source='negmas', description='AgentGP (Gaussian Process Agent) negotiation agent.\n\n**ANAC 2019 competitor.**\n\nModular agent with NegotiationInfo, BidSearch, and NegotiationStrategy\ncomponents. Tracks bids accepted by multiple parties (PBList) and uses\nthem in final phase. Custom utility space estimation using closest\nknown bid approach.\n\n**Offering Strategy:**\n\n    - Uses BidSearch with threshold from NegotiationStrategy\n    - Final phase: offers bids from PBList (bids accepted by others)\n    - Updates time scale to track negotiation progress\n\n**Acceptance Strategy:**\n\n    - Based on NegotiationStrategy threshold\n    - May end negotiation if conditions warrant\n\n**Opponent Modeling:**\n\n    Tracks opponent bids and updates negotiation info per sender.\n    Records bids supported by all other parties.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.', params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'AgentH#6e6122bb': NegotiatorInfo(key='AgentH#6e6122bb', short_name='AgentH', full_type_name='negmas.genius.gnegotiators.y2015.AgentH', cls=<class 'negmas.genius.gnegotiators.y2015.AgentH'>, source='negmas', description='AgentH negotiation agent.\n\n**ANAC 2015**.\n\nUses relative utility search and bid history analysis.\n\n**Offering Strategy:**\n    - Relative utility search based on time progression\n    - Falls back to history-based bid generation\n    - Concedes gradually as time progresses\n\n**Acceptance Strategy:**\n    - Time-dependent acceptance: accepts if utility * time < 0.45\n    - Simple threshold-based decision\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'AgentHP#fa759838': NegotiatorInfo(key='AgentHP#fa759838', short_name='AgentHP', full_type_name='negmas.genius.gnegotiators.y2015.AgentHP', cls=<class 'negmas.genius.gnegotiators.y2015.AgentHP'>, source='negmas', description='AgentHP negotiation agent.\n\n**ANAC 2015**.\n\nUses Analytic Hierarchy Process (AHP) for bid evaluation with pairwise\ncomparison of issues. Tracks opponent behavior using frequency analysis\nand geometric mean calculations.\n\n**Offering Strategy:**\n    - Generates bids within a utility range based on time-dependent threshold\n    - Selects bids that maximize AHP evaluation score\n    - AHP weights derived from pairwise comparison matrix using geometric mean\n\n**Acceptance Strategy:**\n    - Acceptance probability based on opponent concession rate and AHP scores\n    - Considers discounted utility when time pressure increases\n\n**Opponent Modeling:**\n    Frequency-based tracking per opponent:\n\n    - Tracks issue value frequencies across opponent bids\n    - Computes issue weights using geometric mean of frequencies\n    - Updates AHP comparison matrix based on observed preferences\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'AgentHP2#87b08d85': NegotiatorInfo(key='AgentHP2#87b08d85', short_name='AgentHP2', full_type_name='negmas.genius.gnegotiators.y2016.AgentHP2', cls=<class 'negmas.genius.gnegotiators.y2016.AgentHP2'>, source='negmas', description="AgentHP2 negotiation agent.\n\n**ANAC 2016**.\n\nEvolution of AgentHP from ANAC 2015 by Hiroyuki Shinohara. Uses AHP\n(Analytic Hierarchy Process) for bid evaluation with utility space\nprediction for opponents.\n\n**Offering Strategy:**\n\n    - Generates multiple bids within a utility range around threshold\n    - Selects bid with highest AHP evaluation score\n    - Utility threshold decreases over time based on opponent concession\n    - Maximum concession degree limited to 0.35\n\n**Acceptance Strategy:**\n\n    - Probabilistic acceptance based on AHP evaluation\n    - Accepts if utility >= 0.90 or time >= 0.99\n    - Accepts if utility >= current threshold\n    - Considers discount factor in probability calculation\n\n**Opponent Modeling:**\n\n    - Tracks opponent bids and updates utility space predictions\n    - Uses AHP evaluation from opponent's perspective\n    - Estimates opponent's maximum AHP evaluation for concession\n    - Computes variance-based predictions of opponent behavior\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Aydogan, R., et al. (2017). The Seventh International Automated Negotiating\n    Agents Competition (ANAC 2016). Studies in Computational Intelligence.\n    Springer, Cham.", params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'AgentHerb#69ff89bc': NegotiatorInfo(key='AgentHerb#69ff89bc', short_name='AgentHerb', full_type_name='negmas.genius.gnegotiators.y2018.AgentHerb', cls=<class 'negmas.genius.gnegotiators.y2018.AgentHerb'>, source='negmas', description='AgentHerb negotiation agent.\n\n**ANAC 2018 competitor.**\n\nUses logistic regression for opponent modeling. Trains separate models per\nopponent on bid accept/reject history. Uses persistent data for initial\ntraining in repeated negotiations.\n\n**Offering Strategy:**\n\n    - Evaluates bids by: own utility + product of opponent acceptance\n      probabilities\n    - Selects bids maximizing combined score\n\n**Acceptance Strategy:**\n\n    - Accepts if bid utility is acceptable given opponent model predictions\n\n**Opponent Modeling:**\n\n    Logistic regression trained on opponent accept/reject decisions for\n    each bid offered.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'AgentI#7eed0d3e': NegotiatorInfo(key='AgentI#7eed0d3e', short_name='AgentI', full_type_name='negmas.genius.gnegotiators.y2013.AgentI', cls=<class 'negmas.genius.gnegotiators.y2013.AgentI'>, source='negmas', description="AgentI (GAgent) negotiation agent.\n\n**ANAC 2013**.\n\nUses probability-based opponent modeling and sigmoid threshold for\nadaptive concession. Analyzes opponent bid variance to determine\nconcession rate.\n\n**Offering Strategy:**\n\n    - Uses sorted outcome space for efficient bid selection\n    - Sigmoid function controls minimum utility threshold\n    - Threshold adapts based on opponent's variance (willingness to concede)\n    - Near deadline (t > 0.9988): offers from opponent's best bids\n    - Avoids repeating previously offered bids\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent bid was previously offered by self\n    - Accepts if opponent utility > current minimum threshold\n    - Near deadline: accepts if opponent offer > 5th best opponent bid\n    - Respects reservation value as lower bound\n\n**Opponent Modeling:**\n\n    - Tracks variance in opponent bid utility changes\n    - Estimates opponent's concession willingness\n    - Uses probability model to predict future opponent behavior\n    - Width of utility range determined by first opponent bid\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.", params={}, tags={'genius', 'respond', 'anac-2013', 'propose', 'anac'}, extra={}), 'AgentK#66db848b': NegotiatorInfo(key='AgentK#66db848b', short_name='AgentK', full_type_name='negmas.genius.gnegotiators.y2010.AgentK', cls=<class 'negmas.genius.gnegotiators.y2010.AgentK'>, source='negmas', description='AgentK negotiation agent.\n\n**ANAC 2010 Winner**.\n\nAgentK uses adaptive concession based on statistical analysis of opponent\nbehavior, with probabilistic acceptance decisions.\n\n**Offering Strategy:**\n\n    - Maintains a target utility that decreases over time using cubic time function\n    - Estimates opponent\'s maximum likely offer using mean + deviation\n    - Adds randomness ("tremor") to bidding and acceptance to avoid predictability\n    - Searches randomly for bids above the dynamic target utility\n    - Caches and reuses previously generated bids above target\n\n**Acceptance Strategy:**\n\n    - Uses probabilistic acceptance based on multiple factors:\n        - Utility evaluation: how good the offer is compared to estimated max\n        - Satisfaction: how close the offer is to current target\n        - Time pressure: acceptance probability increases with t³\n    - Never accepts with probability 1.0; always has stochastic element\n\n**Opponent Modeling:**\n\n    Statistical approach:\n\n    - Tracks running mean and variance of opponent\'s offers\n    - Estimates maximum expected opponent utility as mean + sqrt(12 × variance)\n    - Uses statistics to set adaptive target utilities\n    - No explicit preference learning, relies on aggregate statistics\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Kawaguchi, S., Fujita, K., & Ito, T. (2011). AgentK: Compromising strategy\n    based on estimated maximum utility for automated negotiating agents.\n    In Complex Automated Negotiations: Theories, Models, and Software\n    Competitions. Studies in Computational Intelligence, vol 435. Springer.', params={}, tags={'genius', 'anac-2010', 'respond', 'propose', 'anac'}, extra={}), 'AgentK2#e3bc29d1': NegotiatorInfo(key='AgentK2#e3bc29d1', short_name='AgentK2', full_type_name='negmas.genius.gnegotiators.y2011.AgentK2', cls=<class 'negmas.genius.gnegotiators.y2011.AgentK2'>, source='negmas', description='AgentK2 negotiation agent.\n\n**ANAC 2011**.\n\nAn enhanced version of AgentK with improved discount factor handling.\nUses statistical opponent modeling to estimate expected utility and\nprobabilistic acceptance decisions.\n\n**Offering Strategy:**\n\n    - Maintains a map of previously offered bids with utilities\n    - Randomly selects from bids above current target utility\n    - If no suitable cached bid exists, generates random bids meeting threshold\n    - Target utility decreases over time using cubic time function: t³\n\n**Acceptance Strategy:**\n\n    - Tracks opponent bid statistics (mean, variance) over all rounds\n    - Calculates acceptance probability based on:\n      - Estimated maximum opponent offer (mean + deviation adjustment)\n      - Dynamic target utility that decreases with time\n      - Discount factor ratio applied to targets\n    - Accepts probabilistically when offer exceeds satisfaction threshold\n\n**Opponent Modeling:**\n\n    Statistical approach tracking:\n\n    - Running mean and variance of opponent utilities\n    - Estimated deviation using √(variance × 12)\n    - Used to predict expected maximum offer from opponent\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Kawaguchi, S., Fujita, K., & Ito, T. (2012). AgentK: Compromising\n    strategy based on estimated maximum utility for automated negotiating\n    agents. In New Trends in Agent-based Complex Automated Negotiations.\n    Studies in Computational Intelligence, vol 383. Springer.', params={}, tags={'genius', 'respond', 'anac', 'propose', 'anac-2011'}, extra={}), 'AgentKF#b2f5f235': NegotiatorInfo(key='AgentKF#b2f5f235', short_name='AgentKF', full_type_name='negmas.genius.gnegotiators.y2013.AgentKF', cls=<class 'negmas.genius.gnegotiators.y2013.AgentKF'>, source='negmas', description='AgentKF negotiation agent.\n\n**ANAC 2013**.\n\nEnhanced version of AgentK with persistent learning across negotiation\nsessions. Stores opponent bid history and adjusts behavior based on\naccumulated experience.\n\n**Offering Strategy:**\n\n    - Maintains sorted bid list by utility\n    - Uses time-based threshold with "tremor" adjustment\n    - Tremor increases near deadline for more aggressive concession\n    - Adjusts based on bid similarity to opponent\'s history\n    - Persists best bids across sessions for learning\n\n**Acceptance Strategy:**\n\n    - Accepts if offered bid utility exceeds current threshold\n    - Threshold computed from target utility and tremor factor\n    - More accepting as deadline approaches\n\n**Opponent Modeling:**\n\n    - Stores all opponent bids across sessions (persistent data)\n    - Computes bid similarity scores against opponent history\n    - Uses accumulated data to predict opponent preferences\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Kawaguchi, S., Fujita, K., & Ito, T. (2012). AgentK: Compromising\n    strategy based on estimated maximum utility for automated negotiating\n    agents. In: *New Trends in Agent-based Complex Automated Negotiations*.\n    Springer.', params={}, tags={'genius', 'respond', 'anac-2013', 'propose', 'anac'}, extra={}), 'AgentKN#d9f751e1': NegotiatorInfo(key='AgentKN#d9f751e1', short_name='AgentKN', full_type_name='negmas.genius.gnegotiators.y2017.AgentKN', cls=<class 'negmas.genius.gnegotiators.y2017.AgentKN'>, source='negmas', description="AgentKN negotiation agent.\n\n**ANAC 2017 Nash Product Category Finalist**.\n\nAgentKN by Keita Nakamura uses Simulated Annealing for bid search and\na sophisticated opponent modeling approach to estimate the maximum\nutility the opponent might offer. It balances self-utility maximization\nwith opponent value frequency analysis.\n\n**Offering Strategy:**\n\n    Uses Simulated Annealing to search for 10 bids that maximize utility\n    while starting from a random initial bid. The bids are then scored\n    using a combined metric:\n\n    score = utility + 0.1^(log10(frequency)+1) * frequency * utility\n\n    where frequency is the sum of opponent-offered value frequencies.\n    This encourages bids that are both high-utility and contain values\n    the opponent has frequently requested.\n\n**Acceptance Strategy:**\n\n    Accepts when the opponent's bid exceeds a dynamic threshold:\n\n    threshold(t) = 1 - (1 - e_max(t)) * t^alpha\n\n    where alpha > 1 controls concession rate and e_max(t) is the\n    estimated maximum utility the opponent might offer, calculated as:\n\n    e_max(t) = mu(t) + (1 - mu(t)) * d(t)\n    d(t) = sqrt(3) * sigma(t) / sqrt(mu(t) * (1 - mu(t)))\n\n    where mu(t) is the mean and sigma(t) is the standard deviation of\n    utilities from opponent offers.\n\n**Opponent Modeling:**\n\n    Tracks value frequencies for each issue across opponent bids:\n\n    - Updates issue weights when consecutive bids have the same value\n    - Maintains normalized value frequency counts per issue\n    - Uses statistical analysis (mean, std) of opponent bid utilities\n      to estimate the opponent's bidding range\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.", params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'AgentLG#fc11956b': NegotiatorInfo(key='AgentLG#fc11956b', short_name='AgentLG', full_type_name='negmas.genius.gnegotiators.y2012.AgentLG', cls=<class 'negmas.genius.gnegotiators.y2012.AgentLG'>, source='negmas', description="AgentLG negotiation agent.\n\n**ANAC 2012**.\n\nA time-dependent agent that is stubborn early but compromises near the\ndeadline. Uses opponent bid history to learn preferences and select\nmutually beneficial offers.\n\n**Offering Strategy:**\n\n    - Phase 1 (t < 0.6): Offers top 25% utility bids incrementally,\n      learns opponent preferences\n    - Phase 2 (0.6 <= t < 0.9995): Starts compromising, chooses bids\n      better for opponent while maintaining own threshold\n    - Final phase (t >= 0.9995): Offers opponent's max utility bid for self\n    - Minimum utility threshold starts at 75% of max\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent offer >= 99% of own last offer utility\n    - Accepts if time > 0.999 and offer >= 90% of own utility\n    - Accepts if offer >= minimum bid utility threshold\n    - Accepts if previously offered same bid\n\n**Opponent Modeling:**\n\n    - Tracks all opponent bids and their utilities\n    - Maintains estimate of opponent's best bid for self\n    - Uses opponent history to select compromise bids\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.", params={}, tags={'genius', 'respond', 'anac-2012', 'propose', 'anac'}, extra={}), 'AgentLarry#c63dd727': NegotiatorInfo(key='AgentLarry#c63dd727', short_name='AgentLarry', full_type_name='negmas.genius.gnegotiators.y2019.AgentLarry', cls=<class 'negmas.genius.gnegotiators.y2019.AgentLarry'>, source='negmas', description="AgentLarry negotiation agent.\n\n**ANAC 2019 competitor.**\n\nUses logistic regression for opponent modeling. Trains separate models\nper opponent on bid accept/reject history. Retrains models each round\nfor better performance. Uses persistent data for history initialization.\n\n**Offering Strategy:**\n\n    - Evaluates each bid by: own utility + product of opponent\n      acceptance probabilities\n    - Iterates through all bids to find best evaluation\n    - Selects bid maximizing combined score\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent's bid rank exceeds next bid rank\n      (accounting for discount factor)\n\n**Opponent Modeling:**\n\n    Logistic regression per opponent, trained on:\n    - Bids they offered (labeled as would-accept)\n    - Bids they rejected (labeled as reject)\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.", params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'AgentLight#d7c2bcbb': NegotiatorInfo(key='AgentLight#d7c2bcbb', short_name='AgentLight', full_type_name='negmas.genius.gnegotiators.y2016.AgentLight', cls=<class 'negmas.genius.gnegotiators.y2016.AgentLight'>, source='negmas', description='AgentLight negotiation agent.\n\n**ANAC 2016**.\n\nUses learning phases with opponent statistics tracking. Identifies\nthe "worthy opponent" for strategic targeting and employs tit-for-tat\ninspired concession.\n\n**Offering Strategy:**\n\n    - Learning phase (first 10 rounds): offers maximum utility bids\n    - Negotiation phase: uses tit-for-tat based concession\n    - Tracks opponent statistics (mean, standard deviation) to guide offers\n    - Selects bids that maximize estimated opponent utility above threshold\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent\'s offer utility exceeds time-dependent threshold\n    - Near deadline (remaining rounds <= 3): uses discounted threshold\n    - Prefers offers from "potential" bid list (accepted by others)\n\n**Opponent Modeling:**\n\n    Per-opponent tracking with:\n\n    - Bid history and value frequency tracking\n    - Mean and standard deviation of offered utilities\n    - Identification of "worthy opponent" (toughest/most cooperative)\n    - Value weights based on frequency analysis\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Aydogan, R., et al. (2017). The Seventh International Automated Negotiating\n    Agents Competition (ANAC 2016). Studies in Computational Intelligence.\n    Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'AgentM#072869ae': NegotiatorInfo(key='AgentM#072869ae', short_name='AgentM', full_type_name='negmas.genius.gnegotiators.y2014.AgentM', cls=<class 'negmas.genius.gnegotiators.y2014.AgentM'>, source='negmas', description='AgentM negotiation agent.\n\n**ANAC 2014**.\n\nUses simulated annealing for bid search with multi-session learning.\n\n**Offering Strategy:**\n\n    - Simulated annealing bid search with neighborhood exploration\n    - Tracks opponent bid frequencies per issue value\n    - Concession rate adapts based on opponent bid variance\n    - Persists last agreed bid across sessions for continuity\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent bid exceeds current target utility\n    - Target utility decreases over time based on opponent behavior\n\n**Opponent Modeling:**\n\n    Frequency-based tracking of opponent preferences per issue value.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'AgentMR#1b82db82': NegotiatorInfo(key='AgentMR#1b82db82', short_name='AgentMR', full_type_name='negmas.genius.gnegotiators.y2012.AgentMR', cls=<class 'negmas.genius.gnegotiators.y2012.AgentMR'>, source='negmas', description="AgentMR negotiation agent.\n\n**ANAC 2012**.\n\nUses sigmoid-based concession with adaptive parameters based on opponent\nbehavior forecasting. Adjusts strategy based on discount factor presence.\n\n**Offering Strategy:**\n\n    - Maintains sorted bid ranking by utility\n    - Generates bid variations from opponent offers meeting threshold\n    - Sigmoid function controls minimum acceptable utility over time\n    - Parameters adapt based on opponent concession forecasting at t=0.5\n    - Near deadline (t > 0.985): offers opponent's best bid if acceptable\n\n**Acceptance Strategy:**\n\n    - Probabilistic acceptance: P = f(utility, time³)\n    - Accepts if P > 0.965 or utility > threshold\n    - Accepts if bid was previously in own bid ranking\n    - Time-cubic function makes deadline acceptance more likely\n\n**Opponent Modeling:**\n\n    - Tracks opponent's maximum offered utility over time\n    - Forecasts opponent concession at t=0.5 to adjust sigmoid parameters\n    - Updates sigmoid gain and percent based on concession rate\n    - Different parameters for discounted vs non-discounted domains\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.", params={}, tags={'genius', 'respond', 'anac-2012', 'propose', 'anac'}, extra={}), 'AgentNP1#967eb067': NegotiatorInfo(key='AgentNP1#967eb067', short_name='AgentNP1', full_type_name='negmas.genius.gnegotiators.y2018.AgentNP1', cls=<class 'negmas.genius.gnegotiators.y2018.AgentNP1'>, source='negmas', description='AgentNP1 negotiation agent.\n\n**ANAC 2018 competitor.**\n\nFrequency-based opponent modeling with issue weight estimation. Tracks\nthe "hardest opponent" based on value frequency differences.\n\n**Offering Strategy:**\n\n    - Generates bids above time-phased thresholds\n    - Threshold: 0.81 at t<0.9, 0.78 at t<0.99\n\n**Acceptance Strategy:**\n\n    - Accepts if utility exceeds current phase threshold\n\n**Opponent Modeling:**\n\n    Estimates opponent issue weights via value frequency analysis.\n    Identifies hardest opponent for strategic adaptation.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'AgentNeo#0f72c823': NegotiatorInfo(key='AgentNeo#0f72c823', short_name='AgentNeo', full_type_name='negmas.genius.gnegotiators.y2015.AgentNeo', cls=<class 'negmas.genius.gnegotiators.y2015.AgentNeo'>, source='negmas', description="AgentNeo negotiation agent.\n\n**ANAC 2015**.\n\nDiscount-aware agent that precomputes bids organized by utility ranges.\nUses similarity-based bid selection with multiple choice methods.\n\n**Offering Strategy:**\n    - Starts with maximum utility bids for first 7 rounds\n    - Precomputes all possible bids and organizes them by utility ranges\n    - Uses three bid selection methods (ChooseBid1/2/3) based on similarity\n      to opponent's previous offers\n    - Considers discount factor when calculating target utility\n\n**Acceptance Strategy:**\n    - Accepts if opponent's bid utility >= current threshold\n    - Accepts if opponent's bid utility >= utility of next planned offer\n    - Threshold decreases over time accounting for discount factor\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.", params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'AgentQuest#4b4c3162': NegotiatorInfo(key='AgentQuest#4b4c3162', short_name='AgentQuest', full_type_name='negmas.genius.gnegotiators.y2014.AgentQuest', cls=<class 'negmas.genius.gnegotiators.y2014.AgentQuest'>, source='negmas', description='AgentQuest negotiation agent.\n\n**ANAC 2014**.\n\nUses Euclidean distance comparison with hardheadedness monitoring.\n\n**Offering Strategy:**\n\n    - Maintains top-10 bids by utility for efficient selection\n    - Compares bids using Euclidean distance to opponent offers\n    - Response time estimation for strategic timing\n\n**Acceptance Strategy:**\n\n    - Concession probability function based on negotiation progress\n    - Monitors opponent hardheadedness over sliding window\n    - Adjusts acceptance threshold based on opponent flexibility\n\n**Opponent Modeling:**\n\n    Sliding window analysis of opponent behavior to detect hardheadedness.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'AgentSmith#a6fe3055': NegotiatorInfo(key='AgentSmith#a6fe3055', short_name='AgentSmith', full_type_name='negmas.genius.gnegotiators.y2010.AgentSmith', cls=<class 'negmas.genius.gnegotiators.y2010.AgentSmith'>, source='negmas', description="AgentSmith negotiation agent.\n\n**ANAC 2010 Finalist**.\n\nAgentSmith (developed by Delft University of Technology) uses bid space\nsampling with opponent preference estimation to find near-Pareto bids.\n\n**Offering Strategy:**\n\n    - Starts with maximum utility bid\n    - Samples bid space and filters bids above utility threshold (0.7)\n    - Sorts bids by combined utility (own + estimated opponent)\n    - Iterates through sorted bids sequentially\n    - Near deadline (>110s of assumed 180s session), offers best opponent bid\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent's bid utility > 0.9 (margin threshold)\n    - Accepts if opponent's bid utility ≥ own last bid's utility\n    - Near deadline: accepts if opponent utility ≥ 0.7\n\n**Opponent Modeling:**\n\n    Frequency-based preference learning:\n\n    - Tracks opponent bid history\n    - Estimates opponent's preference profile from bid patterns\n    - Uses estimated preferences to sort bids by combined utility\n    - Aims for Pareto-efficient outcomes\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Baarslag, T., Hindriks, K., Hendrikx, M., Dirkzwager, A., & Jonker, C.M. (2014).\n    Decoupling Negotiating Agents to Explore the Space of Negotiation Strategies.\n    In Novel Insights in Agent-based Complex Automated Negotiation.\n    Studies in Computational Intelligence, vol 535. Springer.", params={}, tags={'genius', 'anac-2010', 'respond', 'propose', 'anac'}, extra={}), 'AgentSmith2016#17c91ffc': NegotiatorInfo(key='AgentSmith2016#17c91ffc', short_name='AgentSmith2016', full_type_name='negmas.genius.gnegotiators.y2016.AgentSmith2016', cls=<class 'negmas.genius.gnegotiators.y2016.AgentSmith2016'>, source='negmas', description="AgentSmith2016 negotiation agent.\n\n**ANAC 2016**.\n\nModular agent with separate negotiationInfo, bidSearch, and\nnegotiationStrategy         components. Uses simulated annealing for bid search.\n\n**Offering Strategy:**\n\n    - Uses random bid as seed for simulated annealing search\n    - Searches for bids above time-dependent threshold\n    - Threshold decreases gradually over negotiation\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent's bid exceeds current threshold\n    - May end negotiation early based on reservation value\n\n**Opponent Modeling:**\n\n    Frequency-based opponent modeling tracking issue value preferences\n    to guide bid search toward mutually beneficial outcomes.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Aydogan, R., et al. (2017). The Seventh International Automated Negotiating\n    Agents Competition (ANAC 2016). Studies in Computational Intelligence.\n    Springer, Cham.", params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'AgentTD#43734472': NegotiatorInfo(key='AgentTD#43734472', short_name='AgentTD', full_type_name='negmas.genius.gnegotiators.y2014.AgentTD', cls=<class 'negmas.genius.gnegotiators.y2014.AgentTD'>, source='negmas', description='AgentTD negotiation agent.\n\n**ANAC 2014**.\n\nSimple time-dependent strategy with phased concession.\n\n**Offering Strategy:**\n\n    - Random bids above threshold until t=0.95\n    - After t=0.95, offers best bid received from opponent\n    - Straightforward time-pressure based approach\n\n**Acceptance Strategy:**\n\n    - Before t=0.7: accepts if utility >= 0.85\n    - Before t=0.98: accepts if utility >= 0.75\n    - After t=0.98: accepts best available offer\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'AgentTRP#f990e95f': NegotiatorInfo(key='AgentTRP#f990e95f', short_name='AgentTRP', full_type_name='negmas.genius.gnegotiators.y2014.AgentTRP', cls=<class 'negmas.genius.gnegotiators.y2014.AgentTRP'>, source='negmas', description='AgentTRP negotiation agent.\n\n**ANAC 2014**.\n\nMulti-mode strategy with session persistence and adaptive mode selection.\n\n**Offering Strategy:**\n\n    - Multiple search modes: simulated annealing and neighbor search\n    - Mode selection based on agreement rate history from past sessions\n    - Persists negotiation data across sessions\n\n**Acceptance Strategy:**\n\n    - Time-dependent threshold with mode-specific adjustments\n    - Considers past session agreement patterns\n\n**Multi-Session Learning:**\n\n    Tracks agreement rates per mode and selects best-performing strategy.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'AgentW#740a2e8d': NegotiatorInfo(key='AgentW#740a2e8d', short_name='AgentW', full_type_name='negmas.genius.gnegotiators.y2015.AgentW', cls=<class 'negmas.genius.gnegotiators.y2015.AgentW'>, source='negmas', description="AgentW negotiation agent.\n\n**ANAC 2015**.\n\nModular agent with separate components for negotiation info tracking,\nbid searching, and strategy. Uses opponent's last bid as seed for search.\n\n**Offering Strategy:**\n    - Modular design with negotiatingInfo, bidSearch, strategy components\n    - Time-dependent utility threshold that decreases over negotiation\n    - Uses opponent's last bid as seed for bid search\n    - Searches for bids above threshold that may appeal to opponent\n\n**Acceptance Strategy:**\n    - Time-dependent threshold comparison\n    - Accepts if opponent's offer exceeds current threshold\n\n**Opponent Modeling:**\n    Frequency-based model tracking opponent bidding patterns to guide\n    bid generation toward mutually acceptable outcomes.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.", params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'AgentX#03349073': NegotiatorInfo(key='AgentX#03349073', short_name='AgentX', full_type_name='negmas.genius.gnegotiators.y2015.AgentX', cls=<class 'negmas.genius.gnegotiators.y2015.AgentX'>, source='negmas', description="AgentX negotiation agent.\n\n**ANAC 2015**.\n\nModular agent similar to AgentW but uses simulated annealing for bid\nsearch with random bid seeding.\n\n**Offering Strategy:**\n    - Modular design with negotiatingInfo, bidSearch, strategy components\n    - Simulated annealing bid search for finding near-optimal bids\n    - Uses random bid as initial seed (unlike AgentW's opponent-based seed)\n    - Time-dependent concession following threshold curve\n\n**Acceptance Strategy:**\n    - Accepts if opponent's bid utility exceeds current threshold\n    - Threshold decreases over time based on negotiation progress\n\n**Opponent Modeling:**\n    Frequency-based opponent model that tracks issue value frequencies\n    to estimate opponent preferences and guide bid search.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.", params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'AgentYK#1f7cb19f': NegotiatorInfo(key='AgentYK#1f7cb19f', short_name='AgentYK', full_type_name='negmas.genius.gnegotiators.y2014.AgentYK', cls=<class 'negmas.genius.gnegotiators.y2014.AgentYK'>, source='negmas', description='AgentYK negotiation agent.\n\n**ANAC 2014**.\n\nHill climbing search with bid element history tracking.\n\n**Offering Strategy:**\n\n    - Hill climbing with configurable stop criteria\n    - Tracks bid element history with weighted appearance counts\n    - Time-bonus for unexplored bids to encourage diversity\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent bid meets utility threshold\n    - Threshold decreases over negotiation time\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'AgreeableAgent2018#b578919d': NegotiatorInfo(key='AgreeableAgent2018#b578919d', short_name='AgreeableAgent2018', full_type_name='negmas.genius.gnegotiators.y2018.AgreeableAgent2018', cls=<class 'negmas.genius.gnegotiators.y2018.AgreeableAgent2018'>, source='negmas', description='AgreeableAgent2018 negotiation agent.\n\n**ANAC 2018 competitor.**\n\nFrequency-based opponent modeling with roulette wheel bid selection.\nDomain-size aware timing for concession adjustments.\n\n**Offering Strategy:**\n\n    - Time-dependent concession: pMin + (pMax-pMin)*(1-f(t))\n    - Roulette wheel selection among bids in utility range\n    - Selection weighted by opponent model scores\n\n**Acceptance Strategy:**\n\n    - Accepts bids within acceptable utility range based on opponent model\n\n**Opponent Modeling:**\n\n    Frequency-based analysis of opponent bid history to estimate\n    preferences.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'AnacSampleAgent#208f7787': NegotiatorInfo(key='AnacSampleAgent#208f7787', short_name='AnacSampleAgent', full_type_name='negmas.genius.gnegotiators.y2014.AnacSampleAgent', cls=<class 'negmas.genius.gnegotiators.y2014.AnacSampleAgent'>, source='negmas', description='AnacSampleAgent negotiation agent.\n\n**ANAC 2014**.\n\nAgentK-based strategy with simulated annealing and session persistence.\nThis is the same implementation as E2Agent.\n\n**Offering Strategy:**\n\n    - Simulated annealing for bid search\n    - Target utility adaptation based on discount factor\n    - Session data persistence for multi-session learning\n\n**Acceptance Strategy:**\n\n    - Time-dependent acceptance with discount factor awareness\n    - Adapts based on opponent behavior history\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'AresParty#a54eb1d4': NegotiatorInfo(key='AresParty#a54eb1d4', short_name='AresParty', full_type_name='negmas.genius.gnegotiators.y2015.AresParty', cls=<class 'negmas.genius.gnegotiators.y2015.AresParty'>, source='negmas', description='AresParty negotiation agent.\n\n**ANAC 2015**.\n\nDiscount-aware agent with time estimation for remaining rounds and\nadaptive concession strategy. Uses toughness parameter for concession control.\n\n**Offering Strategy:**\n    - Estimates remaining negotiation rounds based on elapsed time\n    - Precomputes bids organized by utility ranges for fast selection\n    - Concession controlled by alpha1=2 toughness parameter\n    - Discount-aware: adjusts target utility based on discount factor\n\n**Acceptance Strategy:**\n    - Terminates if reservation value with discount > predicted maximum\n    - Accepts bids above time-dependent threshold\n    - Threshold calculation considers discount factor and remaining time\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'ArisawaYaki#e1879ac9': NegotiatorInfo(key='ArisawaYaki#e1879ac9', short_name='ArisawaYaki', full_type_name='negmas.genius.gnegotiators.y2014.ArisawaYaki', cls=<class 'negmas.genius.gnegotiators.y2014.ArisawaYaki'>, source='negmas', description='ArisawaYaki negotiation agent.\n\n**ANAC 2014**.\n\nSimulated annealing with sigmoid threshold and adaptive minimum utility.\n\n**Offering Strategy:**\n\n    - Simulated annealing for bid search\n    - Sigmoid-based threshold function for concession\n    - Adjusts minimum utility based on opponent bid average changes\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent offer exceeds sigmoid-based threshold\n    - Threshold adapts based on time and opponent behavior\n\n**Opponent Modeling:**\n\n    Monitors changes in opponent bid averages to detect cooperation.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'AspirationNegotiator#d34fa95c': NegotiatorInfo(key='AspirationNegotiator#d34fa95c', short_name='AspirationNegotiator', full_type_name='negmas.gb.negotiators.timebased.AspirationNegotiator', cls=<class 'negmas.gb.negotiators.timebased.AspirationNegotiator'>, source='negmas', description='Represents a time-based negotiation strategy that is independent of the offers received during the negotiation.\n\nArgs:\n    name: The agent name\n    preferences:  The utility function to attache with the agent\n    max_aspiration: The aspiration level to use for the first offer (or first acceptance decision).\n    aspiration_type: The polynomial aspiration curve type. Here you can pass the exponent as a real value or\n                     pass a string giving one of the predefined types: linear, conceder, boulware.\n    stochastic: If True, the agent will propose outcomes with utility >= the current aspiration level not\n                     outcomes just above it.\n    can_propose: If True, the agent is allowed to propose\n    ranking: If True, the aspiration level will not be based on the utility value but the ranking of the outcome\n             within the presorted list. It is only effective when presort is set to True\n    presort: If True, the negotiator will catch a list of outcomes, presort them and only use them for offers\n             and responses. This is much faster then other option for general continuous utility functions\n             but with the obvious problem of only exploring a discrete subset of the issue space (Decided by\n             the `discrete_outcomes` property of the `NegotiatorMechanismInterface` . If the number of outcomes is\n             very large (i.e. > 10000) and discrete, presort will be forced to be True. You can check if\n             presorting is active in realtime by checking the "presorted" attribute.\n    tolerance: A tolerance used for sampling of outcomes when `presort` is set to False\n    owner: The `Agent` that owns the negotiator.\n    parent: The parent which should be an `GBController`\n\nRemarks:\n\n    - This class provides a different interface to the `TimeBasedConcedingNegotiator` with less control. It is recommonded to use\n      `TimeBasedConcedingNegotiator` or other `TimeBasedNegotiator` negotiators isntead', params={}, tags={'aspiration', 'builtin', 'respond', 'sao', 'propose', 'time-based'}, extra={}), 'Aster#727d157d': NegotiatorInfo(key='Aster#727d157d', short_name='Aster', full_type_name='negmas.genius.gnegotiators.y2014.Aster', cls=<class 'negmas.genius.gnegotiators.y2014.Aster'>, source='negmas', description='Aster negotiation agent.\n\n**ANAC 2014**.\n\nSimulated annealing with multi-session learning and agreement history tracking.\n\n**Offering Strategy:**\n\n    - Simulated annealing bid search\n    - Concession degree monitoring for adaptive behavior\n    - Immediate decision-making based on past agreement patterns\n\n**Acceptance Strategy:**\n\n    - Considers agreement history from previous sessions\n    - Adapts threshold based on learned opponent patterns\n\n**Multi-Session Learning:**\n\n    Tracks and uses agreement history for improved decision-making.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'AteamAgent#2aeb8c14': NegotiatorInfo(key='AteamAgent#2aeb8c14', short_name='AteamAgent', full_type_name='negmas.genius.gnegotiators.y2018.AteamAgent', cls=<class 'negmas.genius.gnegotiators.y2018.AteamAgent'>, source='negmas', description='AteamAgent negotiation agent.\n\n**ANAC 2018 competitor.**\n\nGenerates all possible bids sorted by utility. Estimates opponent utility\nvia bid history frequency analysis. Looks for common issues with opponent.\n\n**Offering Strategy:**\n\n    - First 50% of time: offers maximum utility bid\n    - Later: searches for bids above threshold (0.8 * max utility)\n    - Considers estimated opponent utility for bid selection\n\n**Acceptance Strategy:**\n\n    - Accepts if utility exceeds threshold based on negotiation progress\n\n**Opponent Modeling:**\n\n    Frequency analysis of opponent bid history to estimate their utility\n    function and find common ground.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'Ateamagent#d531cb83': NegotiatorInfo(key='Ateamagent#d531cb83', short_name='Ateamagent', full_type_name='negmas.genius.gnegotiators.y2018.Ateamagent', cls=<class 'negmas.genius.gnegotiators.y2018.Ateamagent'>, source='negmas', description='Ateamagent negotiation agent (alias for AteamAgent).\n\n**ANAC 2018 competitor.**\n\nSee :class:`AteamAgent` for full documentation.\n\nNote:\n    AI-generated summary. May not be fully accurate.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'Atlas#3074304b': NegotiatorInfo(key='Atlas#3074304b', short_name='Atlas', full_type_name='negmas.genius.gnegotiators.y2014.Atlas', cls=<class 'negmas.genius.gnegotiators.y2014.Atlas'>, source='negmas', description='Atlas negotiation agent.\n\n**ANAC 2014**.\n\nDual-mode agent with extensive session learning and discount awareness.\n\n**Offering Strategy:**\n\n    - Two modes: "tension" (aggressive) and "weak" (concessive)\n    - Simulated annealing and neighbor search for bid generation\n    - Mode selection based on session history and opponent type\n\n**Acceptance Strategy:**\n\n    - Mode-dependent acceptance thresholds\n    - Discount factor aware for time-discounted domains\n\n**Multi-Session Learning:**\n\n    Extensive tracking of opponent behavior and agreement patterns.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'Atlas3#cee4b221': NegotiatorInfo(key='Atlas3#cee4b221', short_name='Atlas3', full_type_name='negmas.genius.gnegotiators.y2015.Atlas3', cls=<class 'negmas.genius.gnegotiators.y2015.Atlas3'>, source='negmas', description="Atlas3 negotiation agent.\n\n**ANAC 2015 Winner** (Individual Utility & Nash Product categories).\n\nAtlas3 is a sophisticated negotiation agent developed by Akiyuki Mori that\nuses adaptive strategies based on opponent behavior analysis and game-theoretic\nconcepts.\n\n**Offering Strategy:**\n\n    - Uses appropriate bid searching based on relative utility for linear\n      utility spaces\n    - Applies replacement method based on frequency analysis of opponent's\n      bidding history\n    - Concession function derived from Evolutionary Stable Strategy (ESS)\n      expected utility analysis\n    - Near deadline: cycles through promising bids from opponent's history\n\n**Acceptance Strategy:**\n\n    - Accepts if the offer utility exceeds the current threshold calculated\n      from ESS-based concession function\n    - Near deadline: accepts bids above reservation value from candidate list\n\n**Opponent Modeling:**\n\n    Frequency-based model that tracks opponent's bidding patterns to:\n\n    - Estimate opponent preferences\n    - Identify promising bids that might be acceptable to both parties\n    - Guide bid search towards mutually beneficial outcomes\n\nReferences:\n\n    Mori, A., Ito, T. (2017). Atlas3: A Negotiating Agent Based on Expecting\n    Lower Limit of Concession Function. In: Modern Approaches to Agent-based\n    Complex Automated Negotiation. Studies in Computational Intelligence,\n    vol 674. Springer, Cham. https://doi.org/10.1007/978-3-319-51563-2_11", params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'Atlas32016#bf566b6c': NegotiatorInfo(key='Atlas32016#bf566b6c', short_name='Atlas32016', full_type_name='negmas.genius.gnegotiators.y2016.Atlas32016', cls=<class 'negmas.genius.gnegotiators.y2016.Atlas32016'>, source='negmas', description='Atlas32016 negotiation agent.\n\n**ANAC 2016**.\n\nUpdated version of ANAC 2015 winner Atlas3. Uses concession list\n    strategy for final phase and tracks supporter counts for multilateral.\n\n**Offering Strategy:**\n\n    - Time-dependent threshold with simulated annealing bid search\n    - Final phase: cycles through "CList" (Concession List) of bids\n      supported by other parties\n    - Tracks time scale to determine when to enter final phase\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent bid exceeds threshold\n    - Final phase: accepts bids above reservation value\n    - May end negotiation if utility drops below reservation\n\n**Opponent Modeling:**\n\n    - Tracks supporter count for each bid\n    - Maintains PBList (Popular Bid List) of bids accepted by n-1 parties\n    - Frequency-based preference estimation\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Aydogan, R., et al. (2017). The Seventh International Automated Negotiating\n    Agents Competition (ANAC 2016). Studies in Computational Intelligence.\n    Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'BayesianAgent#69f51124': NegotiatorInfo(key='BayesianAgent#69f51124', short_name='BayesianAgent', full_type_name='negmas.genius.gnegotiators.basic.BayesianAgent', cls=<class 'negmas.genius.gnegotiators.basic.BayesianAgent'>, source='negmas', description='Bayesian learning negotiation agent.\n\nUses Bayesian inference to model opponent preferences by maintaining\nprobability distributions over possible opponent utility functions.\nUpdates beliefs after each opponent offer and uses this model to\nfind mutually beneficial outcomes.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n\nReferences:\n    Hindriks, K., & Tykhonov, D. (2008). Opponent Modelling in Automated\n    Multi-Issue Negotiation Using Bayesian Learning. AAMAS.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'BetaOne#e4831603': NegotiatorInfo(key='BetaOne#e4831603', short_name='BetaOne', full_type_name='negmas.genius.gnegotiators.y2018.BetaOne', cls=<class 'negmas.genius.gnegotiators.y2018.BetaOne'>, source='negmas', description='BetaOne negotiation agent.\n\n**ANAC 2018 competitor.**\n\nUses linear regression to detect opponent "betrayal" via slope analysis.\nFeatures AntiAnalysis component for threshold boxes and history-aware\nselfish ratio adjustment.\n\n**Offering Strategy:**\n\n    - Generates bids based on threshold adjusted by opponent behavior\n    - AntiAnalysis component provides threshold boundaries\n\n**Acceptance Strategy:**\n\n    - Accepts based on utility threshold adjusted by betrayal detection\n\n**Opponent Modeling:**\n\n    Linear regression on opponent concession patterns to detect\n    cooperative vs. competitive behavior (betrayal detection).\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'Betaone#0ce17570': NegotiatorInfo(key='Betaone#0ce17570', short_name='Betaone', full_type_name='negmas.genius.gnegotiators.y2018.Betaone', cls=<class 'negmas.genius.gnegotiators.y2018.Betaone'>, source='negmas', description='Betaone negotiation agent (alias for BetaOne).\n\n**ANAC 2018 competitor.**\n\nSee :class:`BetaOne` for full documentation.\n\nNote:\n    AI-generated summary. May not be fully accurate.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'BoulwareNegotiationParty#1bfb9e80': NegotiatorInfo(key='BoulwareNegotiationParty#1bfb9e80', short_name='BoulwareNegotiationParty', full_type_name='negmas.genius.gnegotiators.basic.BoulwareNegotiationParty', cls=<class 'negmas.genius.gnegotiators.basic.BoulwareNegotiationParty'>, source='negmas', description='Boulware (hardheaded) time-dependent negotiation agent.\n\nImplements a Boulware concession strategy with exponent e < 1, meaning\nit concedes slowly at first and rapidly near the deadline. This is an\naggressive strategy that maintains high demands for most of the negotiation.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n\nReferences:\n    Faratin, P., Sierra, C., & Jennings, N. R. (1998). Negotiation Decision\n    Functions for Autonomous Agents. Robotics and Autonomous Systems.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'BoulwareTBNegotiator#475b526a': NegotiatorInfo(key='BoulwareTBNegotiator#475b526a', short_name='BoulwareTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.BoulwareTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.BoulwareTBNegotiator'>, source='negmas', description='A Boulware time-based negotiator that conceeds sub-linearly', params={}, tags={'builtin', 'respond', 'boulware', 'sao', 'propose', 'time-based'}, extra={}), 'BramAgent#af1228a3': NegotiatorInfo(key='BramAgent#af1228a3', short_name='BramAgent', full_type_name='negmas.genius.gnegotiators.y2011.BramAgent', cls=<class 'negmas.genius.gnegotiators.y2011.BramAgent'>, source='negmas', description="BRAMAgent negotiation agent.\n\n**ANAC 2011**.\n\nA time-dependent negotiator that uses frequency-based opponent modeling\nand maintains a sorted array of candidate bids.\n\n**Offering Strategy:**\n\n    - Pre-generates and sorts all candidate bids by own utility (descending)\n    - Creates offers using opponent modeling (sampling from value frequencies)\n    - Falls back to sorted bid array when modeled bids don't meet threshold\n    - Avoids proposing the same bid too frequently (max 20% frequency)\n\n**Acceptance Strategy:**\n\n    - Time-phased threshold with increasing flexibility:\n      - 0-33%: threshold = max - 7% of range\n      - 33-83%: threshold = max - 15% of range\n      - 83-97%: threshold = max - 30% of range\n      - 97-100%: threshold = max - 80% of range\n    - Accepts if opponent offer meets threshold or exceeds planned counter-offer\n\n**Opponent Modeling:**\n\n    Frequency-based learning from last 10 opponent bids:\n\n    - Tracks value frequency per issue (discrete, real, integer)\n    - Uses frequencies as probability distribution for bid generation\n    - Rolling window: oldest bid removed when new one arrives\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Brzostowski, J., & Kowalczyk, R. (2006). Predicting partner's behaviour\n    in agent negotiation. In Proceedings of AAMAS 2006.", params={}, tags={'genius', 'respond', 'anac', 'propose', 'anac-2011'}, extra={}), 'BramAgent2#78731dd7': NegotiatorInfo(key='BramAgent2#78731dd7', short_name='BramAgent2', full_type_name='negmas.genius.gnegotiators.y2011.BramAgent2', cls=<class 'negmas.genius.gnegotiators.y2011.BramAgent2'>, source='negmas', description='BRAMAgent2 negotiation agent.\n\n**ANAC 2011**.\n\nIdentical to BramAgent - this is an alias wrapper pointing to the same\nJava implementation (agents.anac.y2011.BramAgent.BRAMAgent).\n\nSee BramAgent for full documentation of the strategy.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.', params={}, tags={'genius', 'respond', 'anac', 'propose', 'anac-2011'}, extra={}), 'BraveCat#91a693d9': NegotiatorInfo(key='BraveCat#91a693d9', short_name='BraveCat', full_type_name='negmas.genius.gnegotiators.y2014.BraveCat', cls=<class 'negmas.genius.gnegotiators.y2014.BraveCat'>, source='negmas', description='BraveCat negotiation agent.\n\n**ANAC 2014**.\n\nBOA framework agent with DBOMModel opponent modeling.\n\n**Offering Strategy:**\n\n    - BRTOfferingStrategy for bid selection\n    - BestBid strategy component for optimal bid search\n\n**Acceptance Strategy:**\n\n    - AC_LAST acceptance condition (accepts if better than last offer)\n\n**Opponent Modeling:**\n\n    DBOMModel - Decoupled Bayesian Opponent Model for preference learning.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'CABNegotiator#98f52e34': NegotiatorInfo(key='CABNegotiator#98f52e34', short_name='CABNegotiator', full_type_name='negmas.gb.negotiators.cab.CABNegotiator', cls=<class 'negmas.gb.negotiators.cab.CABNegotiator'>, source='negmas', description='Conceding Accepting Better Strategy (optimal, complete, but not an equilibirum)\n\nArgs:\n     name: Negotiator name\n     parent: Parent controller if any\n     preferences: The preferences of the negotiator\n     ufun: The ufun of the negotiator (overrides prefrences)\n     owner: The `Agent` that owns the negotiator.', params={}, tags={'builtin', 'respond', 'cab-family', 'sao', 'learning', 'propose'}, extra={}), 'CANNegotiator#f9e110f0': NegotiatorInfo(key='CANNegotiator#f9e110f0', short_name='CANNegotiator', full_type_name='negmas.gb.negotiators.cab.CANNegotiator', cls=<class 'negmas.gb.negotiators.cab.CANNegotiator'>, source='negmas', description='Conceding Accepting Not Worse Strategy (optimal, complete, but not an equilibirum)\n\nArgs:\n     name: Negotiator name\n     parent: Parent controller if any\n     preferences: The preferences of the negotiator\n     ufun: The ufun of the negotiator (overrides prefrences)\n     owner: The `Agent` that owns the negotiator.', params={}, tags={'builtin', 'respond', 'cab-family', 'sao', 'learning', 'propose'}, extra={}), 'CARNegotiator#7f2fe921': NegotiatorInfo(key='CARNegotiator#7f2fe921', short_name='CARNegotiator', full_type_name='negmas.gb.negotiators.cab.CARNegotiator', cls=<class 'negmas.gb.negotiators.cab.CARNegotiator'>, source='negmas', description='Conceding Accepting Rational Strategy (neither complete nor an equilibrium)\n\nArgs:\n     name: Negotiator name\n     parent: Parent controller if any\n     preferences: The preferences of the negotiator\n     ufun: The ufun of the negotiator (overrides prefrences)\n     owner: The `Agent` that owns the negotiator.', params={}, tags={'builtin', 'respond', 'cab-family', 'sao', 'learning', 'propose'}, extra={}), 'CUHKAgent#d037fb56': NegotiatorInfo(key='CUHKAgent#d037fb56', short_name='CUHKAgent', full_type_name='negmas.genius.gnegotiators.y2012.CUHKAgent', cls=<class 'negmas.genius.gnegotiators.y2012.CUHKAgent'>, source='negmas', description="CUHKAgent negotiation agent.\n\n**ANAC 2012 Winner**.\n\nCUHKAgent (developed at Chinese University of Hong Kong by Jianye Hao)\nis an adaptive negotiation agent that adjusts its strategy based on\nopponent behavior and time pressure.\n\n**Offering Strategy:**\n\n    - Time-dependent concession with adaptive threshold adjustment\n    - Concession rate adapts based on opponent's toughness degree\n    - In large domains: focuses on high-utility bid range\n    - Near deadline: considers opponent's best offer as fallback\n    - Uses opponent model to select bids favorable to opponent among\n      candidates\n\n**Acceptance Strategy:**\n\n    - Accepts if offer exceeds current utility threshold\n    - Accepts if offer exceeds the utility of planned counter-offer\n    - Near deadline: more lenient acceptance based on opponent's best offer\n    - Adapts acceptance based on predicted maximum achievable utility\n\n**Opponent Modeling:**\n\n    - Tracks opponent's bidding history to estimate preferences\n    - Calculates opponent's concession degree to adapt own strategy\n    - Identifies opponent's maximum offered bid for reference\n    - Uses opponent model to choose mutually beneficial bids\n\nReferences:\n\n    Hao, J., & Leung, H. (2014). CUHKAgent: An Adaptive Negotiation Strategy\n    for Bilateral Negotiations over Multiple Items. In Novel Insights in\n    Agent-based Complex Automated Negotiation. Studies in Computational\n    Intelligence, vol 535. Springer, Tokyo.", params={}, tags={'genius', 'respond', 'anac-2012', 'propose', 'anac'}, extra={}), 'CUHKAgent2015#ed6144b2': NegotiatorInfo(key='CUHKAgent2015#ed6144b2', short_name='CUHKAgent2015', full_type_name='negmas.genius.gnegotiators.y2015.CUHKAgent2015', cls=<class 'negmas.genius.gnegotiators.y2015.CUHKAgent2015'>, source='negmas', description="CUHKAgent2015 negotiation agent.\n\n**ANAC 2015**.\n\nSophisticated agent from Chinese University of Hong Kong with dual-opponent\nmodeling. Tracks both opponents separately with statistical analysis over\nmultiple time intervals.\n\n**Offering Strategy:**\n    - Distance-based bid selection to balance self and opponent utilities\n    - Gaussian probability distribution for utility target selection\n    - Adapts strategy based on time intervals (First/Second/ThirdTimeInterval)\n    - Considers both opponents' estimated preferences in bid selection\n\n**Acceptance Strategy:**\n    - Multi-criteria acceptance considering both opponents' behavior\n    - Statistical analysis of opponent concession patterns over intervals\n    - More lenient acceptance near deadline\n\n**Opponent Modeling:**\n    Dual-opponent tracking with sophisticated statistical analysis:\n\n    - Separate models for each opponent in multilateral negotiation\n    - Divides negotiation into time intervals for trend analysis\n    - Tracks concession patterns, mean utilities, and variance\n    - Uses statistical measures to predict opponent behavior\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.", params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'Caduceus#47a9a370': NegotiatorInfo(key='Caduceus#47a9a370', short_name='Caduceus', full_type_name='negmas.genius.gnegotiators.y2016.Caduceus', cls=<class 'negmas.genius.gnegotiators.y2016.Caduceus'>, source='negmas', description='Caduceus negotiation agent.\n\n**ANAC 2016 Winner** (Individual Utility category).\n\nCaduceus (developed by Taha Gunes) combines multiple negotiation experts\nusing ideas from algorithm portfolios, mixture of experts, and genetic\n    algorithms to make collective decisions.\n\n**Offering Strategy:**\n\n    - Portfolio of 5 expert agents: ParsAgent, RandomDance, Kawaii,\n      Atlas3, and Caduceus2015\n    - Early phase (t < 0.83): offers the best possible bid\n    - Crossover strategy: each expert suggests a bid, then majority\n      voting on each issue value determines final bid content\n    - Experts are weighted by expertise scores (100, 10, 5, 3, 1)\n    - Stochastic selection based on expertise levels\n\n**Acceptance Strategy:**\n\n    - Weighted voting among expert agents\n    - Accepts if weighted score of "accept" votes exceeds "bid" votes\n    - Each expert\'s vote weighted by its expertise score\n\n**Opponent Modeling:**\n\n    Delegated to individual expert agents in the portfolio:\n\n    - ParsAgent, Atlas3, Kawaii each have their own opponent models\n    - Collective decision benefits from diverse modeling approaches\n\nReferences:\n\n    Gunes, T.D., Arditi, E., & Aydogan, R. (2017). Collective Voice of\n    Experts in Multilateral Negotiation. In PRIMA 2017: Principles and\n    Practice of Multi-Agent Systems. Lecture Notes in Computer Science,\n    vol 10621. Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'CaduceusDC16#4bcf9938': NegotiatorInfo(key='CaduceusDC16#4bcf9938', short_name='CaduceusDC16', full_type_name='negmas.genius.gnegotiators.y2017.CaduceusDC16', cls=<class 'negmas.genius.gnegotiators.y2017.CaduceusDC16'>, source='negmas', description="CaduceusDC16 negotiation agent.\n\n**ANAC 2017**.\n\nCaduceusDC16 is a meta-agent that combines 5 sub-agents (YXAgent, ParsCat,\nFarma, MyAgent, Atlas32016) using a weighted voting mechanism. Each\nsub-agent contributes to bid selection and acceptance decisions.\n\n**Offering Strategy:**\n\n    - Each sub-agent proposes a bid and votes on others' proposals\n    - Weighted scoring: 5 (YXAgent), 4 (ParsCat), 3 (Farma), 2 (MyAgent), 1 (Atlas32016)\n    - Uses getMostProposedBidWithWeight() for weighted value voting per issue\n    - Offers best bid early (before 83% * discount factor of time)\n\n**Acceptance Strategy:**\n\n    - Voting mechanism: accepts if accept_score > bid_score\n    - Each sub-agent votes to accept or reject based on its own criteria\n    - Weighted votes determine final decision\n\n**Opponent Modeling:**\n\n    Inherits opponent modeling from each sub-agent, which are combined\n    through the voting mechanism.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.", params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'ClockworkAgent#5beb05f8': NegotiatorInfo(key='ClockworkAgent#5beb05f8', short_name='ClockworkAgent', full_type_name='negmas.genius.gnegotiators.y2016.ClockworkAgent', cls=<class 'negmas.genius.gnegotiators.y2016.ClockworkAgent'>, source='negmas', description='ClockworkAgent negotiation agent.\n\n**ANAC 2016**.\n\nTime-phased strategy using cosine-based utility oscillation for bid\n    generation and time-dependent acceptance thresholds.\n\n**Offering Strategy:**\n\n    - Early phase (t < 0.3): offers maximum utility bids\n    - Mid phase (0.3 <= t < 0.95): oscillating utility target using\n      cosine function (rad increments by π/4 each round)\n    - Late phase (0.95 <= t < 0.97): offers from candidate array of\n      previously accepted bids\n    - Final phase (t > 0.97): returns to maximum utility bids\n    - Uses random search (10,000 iterations) to find bids above target\n\n**Acceptance Strategy:**\n\n    - Time-phased thresholds with discount factor consideration\n    - Early (t <= 0.95): accepts if utility > discounted 0.95\n    - Mid (0.95 < t <= 0.97): accepts if utility > average of\n      discounted value and bottom limit\n    - Late (t > 0.97): accepts if utility > discounted value\n    - Adjusts thresholds based on opponent concession detection\n\n**Opponent Modeling:**\n\n    - Tracks opponent bid history\n    - Detects concession by comparing recent bids (h1 > h2 or h1 > h3)\n    - Stores bids accepted by others as candidates for late-phase offers\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Aydogan, R., et al. (2017). The Seventh International Automated Negotiating\n    Agents Competition (ANAC 2016). Studies in Computational Intelligence.\n    Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'ConDAgent#16c97fde': NegotiatorInfo(key='ConDAgent#16c97fde', short_name='ConDAgent', full_type_name='negmas.genius.gnegotiators.y2018.ConDAgent', cls=<class 'negmas.genius.gnegotiators.y2018.ConDAgent'>, source='negmas', description='ConDAgent negotiation agent.\n\n**ANAC 2018 competitor.**\n\nUses Bayesian opponent modeling for each opponent. IssueManager handles\nthreshold calculation and bid generation.\n\n**Offering Strategy:**\n\n    - Generates bids via IssueManager above dynamic threshold\n    - Considers Bayesian model predictions for bid selection\n\n**Acceptance Strategy:**\n\n    - Accepts immediately if utility > 0.95\n    - Otherwise uses dynamic threshold from IssueManager\n\n**Opponent Modeling:**\n\n    Bayesian model per opponent updated with observed bids to estimate\n    opponent preferences probabilistically.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'ConcederNegotiationParty#a0ea5cd4': NegotiatorInfo(key='ConcederNegotiationParty#a0ea5cd4', short_name='ConcederNegotiationParty', full_type_name='negmas.genius.gnegotiators.basic.ConcederNegotiationParty', cls=<class 'negmas.genius.gnegotiators.basic.ConcederNegotiationParty'>, source='negmas', description='Conceder time-dependent negotiation agent.\n\nImplements a Conceder strategy with exponent e > 1, meaning it concedes\nrapidly at the start and slowly near the deadline. This is a cooperative\nstrategy that quickly lowers demands to reach agreement.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n\nReferences:\n    Faratin, P., Sierra, C., & Jennings, N. R. (1998). Negotiation Decision\n    Functions for Autonomous Agents. Robotics and Autonomous Systems.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'ConcederTBNegotiator#5b587582': NegotiatorInfo(key='ConcederTBNegotiator#5b587582', short_name='ConcederTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.ConcederTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.ConcederTBNegotiator'>, source='negmas', description='A Boulware time-based negotiator that conceeds super-linearly', params={}, tags={'builtin', 'conceder', 'respond', 'sao', 'propose', 'time-based'}, extra={}), 'DandikAgent#de098b40': NegotiatorInfo(key='DandikAgent#de098b40', short_name='DandikAgent', full_type_name='negmas.genius.gnegotiators.y2019.DandikAgent', cls=<class 'negmas.genius.gnegotiators.y2019.DandikAgent'>, source='negmas', description="DandikAgent negotiation agent.\n\n**ANAC 2019 competitor.**\n\nUses OLS (Ordinary Least Squares) regression for utility estimation\nfrom bid rankings. One-hot encodes bids for regression. Handles large\nand small domain sizes differently.\n\n**Offering Strategy:**\n\n    - Time-dependent threshold: stricter early, relaxes over time\n    - t < 900: offers from top 0.5% of bids\n    - t > 990: more concessions allowed\n    - Final rounds: may offer best opponent bid\n\n**Acceptance Strategy:**\n\n    - Accepts if bid utility > 93% of max (varies by time)\n    - Near deadline: accepts based on opponent's max bid utility\n\n**Opponent Modeling:**\n\n    Tracks opponent's best bid for fallback offers near deadline.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.", params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'DoNA#641e9f83': NegotiatorInfo(key='DoNA#641e9f83', short_name='DoNA', full_type_name='negmas.genius.gnegotiators.y2014.DoNA', cls=<class 'negmas.genius.gnegotiators.y2014.DoNA'>, source='negmas', description='DoNA negotiation agent.\n\n**ANAC 2014**.\n\nDomain-size adaptive agent with statistical sampling.\n\n**Offering Strategy:**\n\n    - Falls back to ClearDefaultStrategy for small domains (<1M bids)\n    - Statistical sampling for large outcome spaces\n    - Reservation value and discount factor aware\n\n**Acceptance Strategy:**\n\n    - Adapts based on domain size and complexity\n    - Considers reservation value in acceptance decisions\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'DrageKnight#c1dfa55e': NegotiatorInfo(key='DrageKnight#c1dfa55e', short_name='DrageKnight', full_type_name='negmas.genius.gnegotiators.y2015.DrageKnight', cls=<class 'negmas.genius.gnegotiators.y2015.DrageKnight'>, source='negmas', description='DrageKnight negotiation agent.\n\n**ANAC 2015**.\n\nModular agent similar to AgentW/X family, using simulated annealing\nfor bid search with frequency-based opponent modeling.\n\n**Offering Strategy:**\n    - Modular design with strategy, bidSearch, negotiatingInfo components\n    - Simulated annealing search for bid generation\n    - Uses getThreshold2 method for threshold calculation\n    - Time-dependent concession strategy\n\n**Acceptance Strategy:**\n    - Threshold-based acceptance using getThreshold2\n    - Accepts if opponent bid exceeds calculated threshold\n\n**Opponent Modeling:**\n    Frequency-based model tracking opponent issue value preferences\n    to guide bid search toward mutually beneficial outcomes.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'E2Agent#733fa85f': NegotiatorInfo(key='E2Agent#733fa85f', short_name='E2Agent', full_type_name='negmas.genius.gnegotiators.y2014.E2Agent', cls=<class 'negmas.genius.gnegotiators.y2014.E2Agent'>, source='negmas', description='E2Agent negotiation agent.\n\n**ANAC 2014**.\n\nAgentK-based strategy with simulated annealing and session persistence.\nThis is the same implementation as AnacSampleAgent.\n\n**Offering Strategy:**\n\n    - Simulated annealing for bid search\n    - Target utility adaptation based on discount factor\n    - Session data persistence for multi-session learning\n\n**Acceptance Strategy:**\n\n    - Time-dependent acceptance with discount factor awareness\n    - Adapts based on opponent behavior history\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'EAgent#37637458': NegotiatorInfo(key='EAgent#37637458', short_name='EAgent', full_type_name='negmas.genius.gnegotiators.y2019.EAgent', cls=<class 'negmas.genius.gnegotiators.y2019.EAgent'>, source='negmas', description="EAgent negotiation agent.\n\n**ANAC 2019 competitor.**\n\nDesigned for preference uncertainty. Estimates utility space using\nbid ranking with score-based value estimation and standard deviation\nfor issue weights.\n\n**Offering Strategy:**\n\n    - Always offers max utility bid from estimated utility space\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent's bid utility > 0.8\n\n**Preference Estimation:**\n\n    - Values scored by position in bid ranking\n    - Normalized by occurrence frequency\n    - Issue weights based on inverse of value standard deviation\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.", params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'ExpRubick#cd50135d': NegotiatorInfo(key='ExpRubick#cd50135d', short_name='ExpRubick', full_type_name='negmas.genius.gnegotiators.y2018.ExpRubick', cls=<class 'negmas.genius.gnegotiators.y2018.ExpRubick'>, source='negmas', description='ExpRubick negotiation agent.\n\n**ANAC 2018 competitor.**\n\nAdaptive target utility with emax estimation. Uses frequency-based\nopponent modeling with "bags" of preferred values and history analysis.\n\n**Offering Strategy:**\n\n    - Target utility: 1 - (1-emax) * (0.8t)^(3 + 2*concession - 0.8t)\n    - Generates bids near target considering opponent preferences\n\n**Acceptance Strategy:**\n\n    - Accepts if utility exceeds adaptive target\n\n**Opponent Modeling:**\n\n    Frequency-based with "bags" collecting preferred values per issue\n    for each opponent.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'FSEGA2019#2ba949d9': NegotiatorInfo(key='FSEGA2019#2ba949d9', short_name='FSEGA2019', full_type_name='negmas.genius.gnegotiators.y2019.FSEGA2019', cls=<class 'negmas.genius.gnegotiators.y2019.FSEGA2019'>, source='negmas', description='FSEGA2019 negotiation agent.\n\n**ANAC 2019 competitor.**\n\nUses Bayesian opponent modeling with time-phased strategy (SMART,\nSERIAL, RESPONSIVE, RANDOM, TIT_FOR_TAT). Maintains sorted bid list\nfor efficient bid generation.\n\n**Offering Strategy:**\n\n    - Initial: offers max utility bid\n    - Time phases: t<0.85 (case 0), t<0.95 (case 1), else (case 2)\n    - Makes concessions in final phase (case 2)\n    - Minimum utility threshold: 0.5\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent utility >= 1.03 * own last bid utility\n    - Or if opponent utility > next planned bid utility\n\n**Opponent Modeling:**\n\n    Bayesian opponent model (MyBayesianOpponentModel) updated with\n    each opponent bid to estimate expected utility.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.', params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'Farma#a2d876b6': NegotiatorInfo(key='Farma#a2d876b6', short_name='Farma', full_type_name='negmas.genius.gnegotiators.y2016.Farma', cls=<class 'negmas.genius.gnegotiators.y2016.Farma'>, source='negmas', description='Farma negotiation agent.\n\n**ANAC 2016**.\n\nModular agent with negotiationInfo, bidSearch, and negotiationStrategy\ncomponents. Uses shift-based bid search and tracks opponent behavior\n    per sender.\n\n**Offering Strategy:**\n\n    - Uses time-dependent threshold from negotiationStrategy\n    - Generates bids via bidSearch with random seed and threshold\n    - Shift-based search adjusts bids toward opponent preferences\n    - Tracks own bid history and negotiating statistics\n\n**Acceptance Strategy:**\n\n    - Time-dependent threshold-based acceptance\n    - May terminate negotiation based on reservation value\n    - Updates round counter each action\n\n**Opponent Modeling:**\n\n    Per-opponent tracking including:\n\n    - Bid accept counts per sender (CntBySender)\n    - Offered value frequencies per issue\n    - Separate initialization for new opponents\n    - Round-based statistics updates\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Aydogan, R., et al. (2017). The Seventh International Automated Negotiating\n    Agents Competition (ANAC 2016). Studies in Computational Intelligence.\n    Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'Farma17#e3eac1eb': NegotiatorInfo(key='Farma17#e3eac1eb', short_name='Farma17', full_type_name='negmas.genius.gnegotiators.y2017.Farma17', cls=<class 'negmas.genius.gnegotiators.y2017.Farma17'>, source='negmas', description='Farma17 negotiation agent.\n\n**ANAC 2017**.\n\nFarma17 uses a modular design with NegoStats, BidSearch, NegoHistory, and\nNegoStrategy components. It tracks rejected and agreed values per opponent\nto inform its bidding strategy.\n\n**Offering Strategy:**\n\n    - Time-dependent threshold controls minimum acceptable utility\n    - BidSearch component finds bids above threshold\n    - Considers opponent preferences when selecting among valid bids\n\n**Acceptance Strategy:**\n\n    - Accepts bids above the time-dependent threshold\n    - Updates opponent info when receiving offers or accepts\n\n**Opponent Modeling:**\n\n    - Tracks rejected and agreed values for each opponent\n    - NegoStats maintains statistics on opponent behavior\n    - NegoHistory stores past negotiation data for analysis\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'Farma2017#eee274b7': NegotiatorInfo(key='Farma2017#eee274b7', short_name='Farma2017', full_type_name='negmas.genius.gnegotiators.y2017.Farma2017', cls=<class 'negmas.genius.gnegotiators.y2017.Farma2017'>, source='negmas', description='Farma2017 negotiation agent.\n\n**ANAC 2017**.\n\nAlias for Farma17. Uses the same Java class (agents.anac.y2017.farma.Farma17).\nSee :class:`Farma17` for full documentation.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'FastMiCRONegotiator#fd7b7c9e': NegotiatorInfo(key='FastMiCRONegotiator#fd7b7c9e', short_name='FastMiCRONegotiator', full_type_name='negmas.gb.negotiators.micro.FastMiCRONegotiator', cls=<class 'negmas.gb.negotiators.micro.FastMiCRONegotiator'>, source='negmas', description='Rational Concession Negotiator\n\nArgs:\n     name: Negotiator name\n     parent: Parent controller if any\n     preferences: The preferences of the negotiator\n     ufun: The ufun of the negotiator (overrides prefrences)\n     owner: The `Agent` that owns the negotiator.', params={}, tags={'builtin', 'respond', 'sao', 'learning', 'propose', 'micro'}, extra={}), 'Flinch#0f13a71b': NegotiatorInfo(key='Flinch#0f13a71b', short_name='Flinch', full_type_name='negmas.genius.gnegotiators.y2014.Flinch', cls=<class 'negmas.genius.gnegotiators.y2014.Flinch'>, source='negmas', description='Flinch negotiation agent.\n\n**ANAC 2014**.\n\nGenetic algorithm bid search with kernel-based opponent modeling.\n\n**Offering Strategy:**\n\n    - Genetic algorithm for bid optimization\n    - Population-based search for diverse bid exploration\n\n**Acceptance Strategy:**\n\n    - Time-dependent threshold with discount factor awareness\n    - Adapts based on estimated opponent utility\n\n**Opponent Modeling:**\n\n    Kernel-based estimation of opponent utility from bid history.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'FullAgent#721a0256': NegotiatorInfo(key='FullAgent#721a0256', short_name='FullAgent', full_type_name='negmas.genius.gnegotiators.y2018.FullAgent', cls=<class 'negmas.genius.gnegotiators.y2018.FullAgent'>, source='negmas', description='FullAgent negotiation agent.\n\n**ANAC 2018 competitor.**\n\nBOA framework agent with decoupled components: OpponentModel_lgsmi,\nOMStrategy_lgsmi, OfferingStrategy_lgsmi, AcceptanceStrategy_lgsmi.\nBidsManager tracks opponent bids and acceptances.\n\n**Offering Strategy:**\n\n    - OfferingStrategy_lgsmi component generates offers\n    - Uses opponent model for bid selection optimization\n\n**Acceptance Strategy:**\n\n    - AcceptanceStrategy_lgsmi determines acceptance\n    - Considers opponent model predictions\n\n**Opponent Modeling:**\n\n    OpponentModel_lgsmi with OMStrategy_lgsmi for strategic use of\n    opponent preference estimates.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'FunctionalAcceptor#79359b25': NegotiatorInfo(key='FunctionalAcceptor#79359b25', short_name='FunctionalAcceptor', full_type_name='negmas.genius.gnegotiators.basic.FunctionalAcceptor', cls=<class 'negmas.genius.gnegotiators.basic.FunctionalAcceptor'>, source='negmas', description='Functional acceptance strategy agent.\n\nAn agent that only decides whether to accept or reject opponent offers\nbased on a utility threshold function. Does not generate counter-offers.\nUseful as a baseline or as a component in BOA (Bidding-Opponent-Acceptance)\narchitecture.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n\nReferences:\n    Baarslag, T., et al. (2014). Decoupling Negotiating Agents to Explore\n    the Space of Negotiation Strategies. AAMAS.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'FuzzyAgent#1c78e39f': NegotiatorInfo(key='FuzzyAgent#1c78e39f', short_name='FuzzyAgent', full_type_name='negmas.genius.gnegotiators.basic.FuzzyAgent', cls=<class 'negmas.genius.gnegotiators.basic.FuzzyAgent'>, source='negmas', description='Fuzzy logic-based negotiation agent.\n\nUses fuzzy logic rules to determine negotiation behavior including\nconcession making and offer evaluation. Fuzzy membership functions\nmodel concepts like "good offer" or "near deadline" for more\nhuman-like decision making.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n\nReferences:\n    Kowalczyk, R., & Bui, V. (2000). On Fuzzy E-Negotiation Agents.\n    World Congress on Computational Intelligence.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'GAgent#8a160495': NegotiatorInfo(key='GAgent#8a160495', short_name='GAgent', full_type_name='negmas.genius.gnegotiators.y2013.GAgent', cls=<class 'negmas.genius.gnegotiators.y2013.GAgent'>, source='negmas', description='GAgent negotiation agent.\n\n**ANAC 2013**.\n\nAlias for AgentI - both use the same underlying Java implementation.\nSee :class:`AgentI` for full documentation.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.', params={}, tags={'genius', 'respond', 'anac-2013', 'propose', 'anac'}, extra={}), 'Gahboninho#3c4a49e7': NegotiatorInfo(key='Gahboninho#3c4a49e7', short_name='Gahboninho', full_type_name='negmas.genius.gnegotiators.y2011.Gahboninho', cls=<class 'negmas.genius.gnegotiators.y2011.Gahboninho'>, source='negmas', description='Gahboninho negotiation agent.\n\n**ANAC 2011**.\n\nA "bully" strategy agent that maintains high demands throughout most of\nthe negotiation and only concedes significantly near the deadline. The\nagent exploits cooperative opponents by staying selfish when detecting\nniceness.\n\n**Offering Strategy:**\n\n    - First 40 bids: gradually decreases from max utility to 0.925\n      (allows opponent profiling)\n    - After profiling: generates bids at recommended threshold\n    - Uses opponent "noise" (niceness estimate) to adjust selfishness\n    - Nicer opponents receive less generous offers\n    - In "frenzy" mode (near deadline): offers best opponent bid seen\n\n**Acceptance Strategy:**\n\n    - First 40 rounds: accepts only if utility > 0.95\n    - Normal phase: accepts based on dynamic minimum threshold\n    - Threshold stays high while opponent appears cooperative\n    - Near deadline: accepts best opponent bid if reasonable\n\n**Opponent Modeling:**\n\n    - Tracks opponent bid history and importance weights\n    - Estimates "noise" as a niceness indicator\n    - Filters bids late in negotiation based on opponent preferences\n    - More selfish behavior toward nicer opponents\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.', params={}, tags={'genius', 'respond', 'anac', 'propose', 'anac-2011'}, extra={}), 'Gangester#701e369e': NegotiatorInfo(key='Gangester#701e369e', short_name='Gangester', full_type_name='negmas.genius.gnegotiators.y2014.Gangester', cls=<class 'negmas.genius.gnegotiators.y2014.Gangester'>, source='negmas', description='Gangester negotiation agent (alternate spelling of Gangster).\n\n**ANAC 2014**.\n\nGenetic algorithm for nonlinear domains with bid storage.\n\n**Offering Strategy:**\n\n    - Genetic algorithm for nonlinear utility spaces\n    - Local and global search strategies\n    - Concession based on max distance to opponent bids\n    - Bid storage with reproposal capability\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent bid utility exceeds threshold\n    - Threshold decreases based on time and opponent behavior\n\n**Opponent Modeling:**\n\n    Distance-based analysis of opponent bid patterns.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'Gangster#b3024496': NegotiatorInfo(key='Gangster#b3024496', short_name='Gangster', full_type_name='negmas.genius.gnegotiators.y2014.Gangster', cls=<class 'negmas.genius.gnegotiators.y2014.Gangster'>, source='negmas', description='Gangster negotiation agent.\n\n**ANAC 2014**.\n\nGenetic algorithm for nonlinear domains with bid storage.\n\n**Offering Strategy:**\n\n    - Genetic algorithm for nonlinear utility spaces\n    - Local and global search strategies\n    - Concession based on max distance to opponent bids\n    - Bid storage with reproposal capability\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent bid utility exceeds threshold\n    - Threshold decreases based on time and opponent behavior\n\n**Opponent Modeling:**\n\n    Distance-based analysis of opponent bid patterns.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'GaravelAgent#ab9021bd': NegotiatorInfo(key='GaravelAgent#ab9021bd', short_name='GaravelAgent', full_type_name='negmas.genius.gnegotiators.y2019.GaravelAgent', cls=<class 'negmas.genius.gnegotiators.y2019.GaravelAgent'>, source='negmas', description='GaravelAgent negotiation agent.\n\n**ANAC 2019 competitor.**\n\nUses OLS regression for utility estimation and frequency-based\nopponent modeling. Generates optimal bids considering both own\nand opponent preferences.\n\n**Offering Strategy:**\n\n    - Early: offers max utility bid\n    - After round 200: selects from optimal bids (considering\n      opponent model)\n    - Final rounds: strategic bid selection\n\n**Acceptance Strategy:**\n\n    - Accepts if estimated utility >= 0.92\n    - Final round: accepts if utility >= 0.84\n\n**Opponent Modeling:**\n\n    Frequency-based tracking of opponent value preferences.\n    Updates issue and value weights from opponent bid history.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.', params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'GeneKing#68be872f': NegotiatorInfo(key='GeneKing#68be872f', short_name='GeneKing', full_type_name='negmas.genius.gnegotiators.y2017.GeneKing', cls=<class 'negmas.genius.gnegotiators.y2017.GeneKing'>, source='negmas', description='GeneKing negotiation agent.\n\n**ANAC 2017**.\n\nGeneKing uses a genetic algorithm approach to bid generation. It maintains\na gene pool of bids and evolves them using crossover and mutation operators\ninformed by opponent preferences.\n\n**Offering Strategy:**\n\n    - Maintains a gene pool of candidate bids\n    - Crossover with frequency weighting based on opponent value preferences\n    - Mutation with 1/70 probability per issue\n    - Bid evaluation: util*utilWeight + sim*simWeight + exUtil1 + exUtil2 - diff\n    - Uses negotiation history for initial population\n\n**Acceptance Strategy:**\n\n    - Accepts bids that meet utility threshold criteria\n    - Threshold adapts based on time and opponent behavior\n\n**Opponent Modeling:**\n\n    - Tracks frequency per issue/value for each opponent\n    - Uses frequency data to weight crossover operations\n    - Higher frequency values more likely selected during evolution\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'Gin#16ac262a': NegotiatorInfo(key='Gin#16ac262a', short_name='Gin', full_type_name='negmas.genius.gnegotiators.y2017.Gin', cls=<class 'negmas.genius.gnegotiators.y2017.Gin'>, source='negmas', description='Gin negotiation agent.\n\n**ANAC 2017**.\n\nGin builds a frequency table per issue across all opponents and uses\nnegotiation history to adapt its concession behavior based on past\nsuccess/failure rates.\n\n**Offering Strategy:**\n\n    - Builds frequency table of opponent-preferred values per issue\n    - Selects bids sorted by alignment with frequency table\n    - History-aware: adjusts fitToOpponent (0/1/2) based on failure rate\n    - More aggressive if failure rate > 40%, moderate if > 20%\n\n**Acceptance Strategy:**\n\n    - Three-tier threshold system: 0.9 / 0.88 / 0.80\n    - Thresholds adjust more aggressively if history shows failures\n    - Accepts when opponent bid exceeds current threshold\n\n**Opponent Modeling:**\n\n    - Aggregates value frequencies across all opponents\n    - Uses frequency data to select mutually beneficial bids\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'GrandmaAgent#4e9e5b42': NegotiatorInfo(key='GrandmaAgent#4e9e5b42', short_name='GrandmaAgent', full_type_name='negmas.genius.gnegotiators.y2016.GrandmaAgent', cls=<class 'negmas.genius.gnegotiators.y2016.GrandmaAgent'>, source='negmas', description='GrandmaAgent negotiation agent.\n\n**ANAC 2016**.\n\nProximity-based bidding strategy that generates random bids above a\nthreshold and selects the one closest to opponents\' "mean" preferences.\n    Developed by Teo Cherici, Maarten de Vries, and Tim Resink.\n\n**Offering Strategy:**\n\n    - Generates N random bids (default 15) above lower bound utility\n    - Calculates proximity of each bid to opponents\' normalized mean\n    - Selects bid with highest proximity score\n    - Lower bound utility decreases over time using exponential factor\n    - Supports both discrete and integer issue types\n\n**Acceptance Strategy:**\n\n    - Accepts if offered utility > lower bound utility AND\n      offered utility > reservation value (MAU)\n    - Lower bound starts at 0.95 and decreases based on discounted\n      mean utility and time factor\n\n**Opponent Modeling:**\n\n    Frequency-based tracking for all parties:\n\n    - Counts how often each issue value is offered\n    - Normalizes frequencies to compute mean preferences\n    - For integer issues: tracks above/below median counts\n    - Computes discounted mean utility with configurable sensitivity\n    - Time-exponential factor adjusts convergence speed\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Aydogan, R., et al. (2017). The Seventh International Automated Negotiating\n    Agents Competition (ANAC 2016). Studies in Computational Intelligence.\n    Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'Gravity#28ae7cb0': NegotiatorInfo(key='Gravity#28ae7cb0', short_name='Gravity', full_type_name='negmas.genius.gnegotiators.y2019.Gravity', cls=<class 'negmas.genius.gnegotiators.y2019.Gravity'>, source='negmas', description="Gravity negotiation agent.\n\n**ANAC 2019 competitor.**\n\nUses Copeland matrices for preference learning from bid rankings.\nPairwise comparison of bids fills frequency matrices used to estimate\nvalue and issue utilities.\n\n**Offering Strategy:**\n\n    - First half of time: offers best bid\n    - Second half: offers bids fixing opponent's most important\n      issue at their preferred value\n    - Occasionally sends best bid to confuse opponent\n\n**Acceptance Strategy:**\n\n    - Accepts if: next bid utility <= received bid utility AND\n      last offer utility <= received bid utility AND\n      opponent utility decreased AND utility > reservation\n\n**Opponent Modeling:**\n\n    Frequency arrays track opponent value preferences. Issue utilities\n    estimated via sum of squared errors from frequency distribution.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.", params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'Group1#ace10132': NegotiatorInfo(key='Group1#ace10132', short_name='Group1', full_type_name='negmas.genius.gnegotiators.others.Group1', cls=<class 'negmas.genius.gnegotiators.others.Group1'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 1 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group10#3410f21c': NegotiatorInfo(key='Group10#3410f21c', short_name='Group10', full_type_name='negmas.genius.gnegotiators.others.Group10', cls=<class 'negmas.genius.gnegotiators.others.Group10'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 10 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group11#72010eea': NegotiatorInfo(key='Group11#72010eea', short_name='Group11', full_type_name='negmas.genius.gnegotiators.others.Group11', cls=<class 'negmas.genius.gnegotiators.others.Group11'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 11 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group12#d595d819': NegotiatorInfo(key='Group12#d595d819', short_name='Group12', full_type_name='negmas.genius.gnegotiators.others.Group12', cls=<class 'negmas.genius.gnegotiators.others.Group12'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 12 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group13#3136cb60': NegotiatorInfo(key='Group13#3136cb60', short_name='Group13', full_type_name='negmas.genius.gnegotiators.others.Group13', cls=<class 'negmas.genius.gnegotiators.others.Group13'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 13 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group14#cb4ab8fe': NegotiatorInfo(key='Group14#cb4ab8fe', short_name='Group14', full_type_name='negmas.genius.gnegotiators.others.Group14', cls=<class 'negmas.genius.gnegotiators.others.Group14'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 14 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group15#cb0a9952': NegotiatorInfo(key='Group15#cb0a9952', short_name='Group15', full_type_name='negmas.genius.gnegotiators.others.Group15', cls=<class 'negmas.genius.gnegotiators.others.Group15'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 15 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group16#c2de0757': NegotiatorInfo(key='Group16#c2de0757', short_name='Group16', full_type_name='negmas.genius.gnegotiators.others.Group16', cls=<class 'negmas.genius.gnegotiators.others.Group16'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 16 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group17#e066fbb0': NegotiatorInfo(key='Group17#e066fbb0', short_name='Group17', full_type_name='negmas.genius.gnegotiators.others.Group17', cls=<class 'negmas.genius.gnegotiators.others.Group17'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 17 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group18#247ffa04': NegotiatorInfo(key='Group18#247ffa04', short_name='Group18', full_type_name='negmas.genius.gnegotiators.others.Group18', cls=<class 'negmas.genius.gnegotiators.others.Group18'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 18 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group19#15671166': NegotiatorInfo(key='Group19#15671166', short_name='Group19', full_type_name='negmas.genius.gnegotiators.others.Group19', cls=<class 'negmas.genius.gnegotiators.others.Group19'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 19 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group1BOA#ee743a24': NegotiatorInfo(key='Group1BOA#ee743a24', short_name='Group1BOA', full_type_name='negmas.genius.gnegotiators.y2019.Group1BOA', cls=<class 'negmas.genius.gnegotiators.y2019.Group1BOA'>, source='negmas', description='Group1BOA (PodAgent) negotiation agent.\n\n**ANAC 2019 competitor.**\n\nBOA framework agent with custom components: Group1_AS (acceptance),\nGroup1_BS (bidding), Group1_OM (opponent model). Uses exponential\nutility distribution for preference estimation.\n\n**Offering Strategy:**\n\n    - Group1_BS component generates offers\n    - Considers opponent model for bid selection\n\n**Acceptance Strategy:**\n\n    - Group1_AS determines acceptance based on utility thresholds\n\n**Preference Estimation:**\n\n    - Augments bid ranking with random bids placed by distance\n    - Exponential utility function: low + (high-low) * (i/n)^2\n    - Issue weights based on variance of value occurrences\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.', params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'Group2#aaa18390': NegotiatorInfo(key='Group2#aaa18390', short_name='Group2', full_type_name='negmas.genius.gnegotiators.y2015.Group2', cls=<class 'negmas.genius.gnegotiators.y2015.Group2'>, source='negmas', description="Group2 negotiation agent.\n\n**ANAC 2015**.\n\nUses Pareto-optimal bid search with per-party opponent modeling.\nEstimates remaining rounds to adapt concession timing.\n\n**Offering Strategy:**\n    - Pareto-optimal bid search using G2ParetoFinder class\n    - Searches Pareto frontier for bids above minimum utility threshold\n    - Time-dependent minimum utility with round estimation\n    - Adapts bid selection based on negotiation progress\n\n**Acceptance Strategy:**\n    - Accepts if opponent bid exceeds time-dependent threshold\n    - Threshold considers estimated remaining rounds\n    - More lenient as deadline approaches\n\n**Opponent Modeling:**\n    Per-party opponent modeling tracking each opponent's preferences\n    separately to find Pareto-optimal bids acceptable to all parties.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.", params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'Group20#69434795': NegotiatorInfo(key='Group20#69434795', short_name='Group20', full_type_name='negmas.genius.gnegotiators.others.Group20', cls=<class 'negmas.genius.gnegotiators.others.Group20'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 20 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group21#0daf8f98': NegotiatorInfo(key='Group21#0daf8f98', short_name='Group21', full_type_name='negmas.genius.gnegotiators.others.Group21', cls=<class 'negmas.genius.gnegotiators.others.Group21'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 21 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group22#3427d00a': NegotiatorInfo(key='Group22#3427d00a', short_name='Group22', full_type_name='negmas.genius.gnegotiators.others.Group22', cls=<class 'negmas.genius.gnegotiators.others.Group22'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 22 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group3#a104e585': NegotiatorInfo(key='Group3#a104e585', short_name='Group3', full_type_name='negmas.genius.gnegotiators.y2017.Group3', cls=<class 'negmas.genius.gnegotiators.y2017.Group3'>, source='negmas', description='Group3 negotiation agent.\n\n**ANAC 2017**.\n\nGroup3 tracks assumed values per opponent and uses history-based minimum\nutility adjustments. It merges opponent preferences to generate bids that\nare likely acceptable to multiple parties.\n\n**Offering Strategy:**\n\n    - Tracks assumed values per opponent (increments when same value repeated)\n    - Merges opponent preferences to generate consensus bids\n    - History-based minimum utility adjustment\n\n**Acceptance Strategy:**\n\n    - Time-based acceptance thresholds:\n\n      - 0.85 when time < 0.5\n      - 0.75 when time < 0.8\n      - 0.70 when time < 0.9\n      - Accepts any offer when time > 0.95\n\n**Opponent Modeling:**\n\n    - Increments value weights when opponents repeat the same value\n    - Merges preferences across opponents to find common ground\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'Group3Q2015#e9bd27ce': NegotiatorInfo(key='Group3Q2015#e9bd27ce', short_name='Group3Q2015', full_type_name='negmas.genius.gnegotiators.others.Group3Q2015', cls=<class 'negmas.genius.gnegotiators.others.Group3Q2015'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 3 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group4#c8b99c3f': NegotiatorInfo(key='Group4#c8b99c3f', short_name='Group4', full_type_name='negmas.genius.gnegotiators.others.Group4', cls=<class 'negmas.genius.gnegotiators.others.Group4'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 4 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group5#d7d3f106': NegotiatorInfo(key='Group5#d7d3f106', short_name='Group5', full_type_name='negmas.genius.gnegotiators.others.Group5', cls=<class 'negmas.genius.gnegotiators.others.Group5'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 5 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group6#916b8ff3': NegotiatorInfo(key='Group6#916b8ff3', short_name='Group6', full_type_name='negmas.genius.gnegotiators.others.Group6', cls=<class 'negmas.genius.gnegotiators.others.Group6'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 6 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group7#eb701168': NegotiatorInfo(key='Group7#eb701168', short_name='Group7', full_type_name='negmas.genius.gnegotiators.others.Group7', cls=<class 'negmas.genius.gnegotiators.others.Group7'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 7 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group8#68a44e80': NegotiatorInfo(key='Group8#68a44e80', short_name='Group8', full_type_name='negmas.genius.gnegotiators.others.Group8', cls=<class 'negmas.genius.gnegotiators.others.Group8'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 8 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'Group9#5ae65fc9': NegotiatorInfo(key='Group9#5ae65fc9', short_name='Group9', full_type_name='negmas.genius.gnegotiators.others.Group9', cls=<class 'negmas.genius.gnegotiators.others.Group9'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 9 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'GroupY#06a9e7d3': NegotiatorInfo(key='GroupY#06a9e7d3', short_name='GroupY', full_type_name='negmas.genius.gnegotiators.y2018.GroupY', cls=<class 'negmas.genius.gnegotiators.y2018.GroupY'>, source='negmas', description='GroupY negotiation agent.\n\n**ANAC 2018 competitor.**\n\nOpponent model per agent tracking value frequencies. History-aware\ninitialization from previous sessions.\n\n**Offering Strategy:**\n\n    - First 3 rounds: offers best bid\n    - Later: uses opponent model scoring for bid selection\n    - Time-based phases at 0.5 and 0.2 remaining time\n\n**Acceptance Strategy:**\n\n    - Time-based utility thresholds with phase transitions\n\n**Opponent Modeling:**\n\n    Tracks value frequency per opponent to estimate preferences.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'HardDealer#4fdf4bf5': NegotiatorInfo(key='HardDealer#4fdf4bf5', short_name='HardDealer', full_type_name='negmas.genius.gnegotiators.y2019.HardDealer', cls=<class 'negmas.genius.gnegotiators.y2019.HardDealer'>, source='negmas', description='HardDealer negotiation agent.\n\n**ANAC 2019 competitor.**\n\nBOA framework agent with Boulware-like behavior. Uses linear\nprogramming (Simplex solver) for utility estimation and\nvariance/spread-based issue weight estimation.\n\n**Offering Strategy:**\n\n    - Time-dependent with concession parameter e = 1.8/deadline\n    - Boulware-like: concedes slowly, more at end\n\n**Acceptance Strategy:**\n\n    - HardDealer_AS component with hardheaded behavior\n\n**Preference Estimation:**\n\n    - Linear programming minimizes slack variables for bid ranking\n    - Issue weights from variance and spread of value positions\n    - Blend variable adjusts ratio based on bid ranking size\n\n**Opponent Modeling:**\n\n    HardDealer_OM with HardDealer_OMS strategy for utilizing\n    opponent preference estimates.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.', params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'HardHeaded#7be7a2b1': NegotiatorInfo(key='HardHeaded#7be7a2b1', short_name='HardHeaded', full_type_name='negmas.genius.gnegotiators.y2011.HardHeaded', cls=<class 'negmas.genius.gnegotiators.y2011.HardHeaded'>, source='negmas', description="HardHeaded negotiation agent.\n\n**ANAC 2011 Winner** (Individual Utility category).\n\nAs the name implies, HardHeaded (developed by Thijs van Krimpen) is an\naggressive negotiator that maintains high demands throughout most of the\nnegotiation and only concedes near the deadline.\n\n**Offering Strategy:**\n\n    - Uses a monotonic concession function that generates bids in decreasing\n      utility order\n    - Cycles through the same range of high-utility bids for most of the\n      negotiation\n    - Resets to a random bid after reaching the dynamic concession limit\n    - Selects bids that maximize estimated opponent utility among equivalent\n      bids for itself\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent's offer exceeds the lowest utility offered so far\n    - Accepts if opponent's offer is better than the next planned offer\n    - Very conservative early acceptance thresholds\n\n**Opponent Modeling:**\n\n    Frequency-based learning approach:\n\n    - Tracks unchanged issues between consecutive opponent bids to estimate\n      issue weights\n    - Counts value frequencies to estimate value utilities\n    - Uses learned model to select bids favorable to opponent among\n      equivalent options\n\nReferences:\n\n    van Krimpen, T., Looije, D., & Hajizadeh, S. (2013). HardHeaded.\n    In Complex Automated Negotiations: Theories, Models, and Software\n    Competitions. Studies in Computational Intelligence, vol 435.\n    Springer, Berlin, Heidelberg.", params={}, tags={'genius', 'respond', 'anac', 'propose', 'anac-2011'}, extra={}), 'IAMcrazyHaggler#2ca54c9b': NegotiatorInfo(key='IAMcrazyHaggler#2ca54c9b', short_name='IAMcrazyHaggler', full_type_name='negmas.genius.gnegotiators.y2010.IAMcrazyHaggler', cls=<class 'negmas.genius.gnegotiators.y2010.IAMcrazyHaggler'>, source='negmas', description="IAMcrazyHaggler negotiation agent.\n\n**ANAC 2010 Finalist** (University of Southampton).\n\nIAMcrazyHaggler is a simple but effective hardball strategy that randomly\nsamples high-utility bids without any concession over time.\n\n**Offering Strategy:**\n\n    - Generates random bids from the outcome space\n    - Only offers bids with utility > 0.9 (or 0.95 in discounted domains)\n    - No time-dependent concession - maintains hard position throughout\n    - Completely ignores opponent's preferences and offers\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent's bid × 1.02 ≥ own last bid's utility\n    - Accepts if opponent's bid × 1.02 ≥ 0.85 (maximum aspiration)\n    - Adjusts thresholds slightly for discounted utility spaces\n\n**Opponent Modeling:**\n\n    None - this agent does not model the opponent at all.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Williams, C.R., Robu, V., Gerding, E.H., & Jennings, N.R. (2011).\n    An Overview of the Results and Insights from the First Automated\n    Negotiating Agents Competition (ANAC 2010). In New Trends in Agent-Based\n    Complex Automated Negotiations. Studies in Computational Intelligence,\n    vol 383. Springer.", params={}, tags={'genius', 'anac-2010', 'respond', 'propose', 'anac'}, extra={}), 'IAMhaggler#5ec0b3ff': NegotiatorInfo(key='IAMhaggler#5ec0b3ff', short_name='IAMhaggler', full_type_name='negmas.genius.gnegotiators.y2010.IAMhaggler', cls=<class 'negmas.genius.gnegotiators.y2010.IAMhaggler'>, source='negmas', description="IAMhaggler negotiation agent.\n\n**ANAC 2012 Winner** (Nash Product category).\n\nIAMhaggler (developed by Colin R. Williams at University of Southampton)\nuses Gaussian Process regression to predict opponent behavior and\noptimize concession timing.\n\n**Offering Strategy:**\n\n    - Uses Gaussian Process to predict when opponent will make maximum\n      concession\n    - Calculates expected utility surface over time and utility dimensions\n    - Target utility based on interpolation toward predicted best agreement\n    - Limits concession based on observed opponent bidding range\n    - Risk-aware utility function with configurable risk parameter\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent's offer * multiplier >= target utility\n    - Accepts if opponent's offer * multiplier >= maximum aspiration (0.9)\n    - Accepts if opponent's offer >= planned bid utility\n    - Multiple acceptance thresholds for robustness\n\n**Opponent Modeling:**\n\n    Gaussian Process regression approach:\n\n    - Tracks opponent utilities over time slots\n    - Fits GP model to predict future opponent concessions\n    - Calculates probability distribution of opponent's future offers\n    - Uses predictions to optimize concession timing\n    - Incorporates discounting factor for time-sensitive domains\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Williams, C.R., Robu, V., Gerding, E.H., & Jennings, N.R. (2012).\n    IAMhaggler: A Negotiation Agent for Complex Environments.\n    In New Trends in Agent-Based Complex Automated Negotiations.\n    Studies in Computational Intelligence, vol 383. Springer.", params={}, tags={'genius', 'anac-2010', 'respond', 'propose', 'anac'}, extra={}), 'IAMhaggler2011#a8ab94dd': NegotiatorInfo(key='IAMhaggler2011#a8ab94dd', short_name='IAMhaggler2011', full_type_name='negmas.genius.gnegotiators.y2011.IAMhaggler2011', cls=<class 'negmas.genius.gnegotiators.y2011.IAMhaggler2011'>, source='negmas', description='IAMhaggler2011 negotiation agent.\n\n**ANAC 2011**.\n\nA sophisticated agent using Gaussian Process regression to predict\nopponent behavior and optimize expected utility over time. Developed\nby the University of Southampton team.\n\n**Offering Strategy:**\n\n    - Uses Bayesian Monte Carlo GP regression to model opponent concession\n    - Computes expected utility surface over (time, utility) space\n    - Factors in discount factor and risk parameter (default 3.0)\n    - Targets utility that maximizes expected agreement value\n    - Generates random bids within ±0.025 of target utility\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent utility × 1.02 >= own last bid utility\n    - Accepts if opponent utility × 1.02 >= 0.9 (MAXIMUM_ASPIRATION)\n    - Accepts if opponent utility × 1.02 >= planned counter-offer\n\n**Opponent Modeling:**\n\n    Gaussian Process regression with:\n\n    - Matern 3/2 covariance function + noise\n    - Time-slotted sampling (36 slots) of opponent max utility\n    - Predicts probability distribution of future opponent offers\n    - Updates regression when time slot changes\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Williams, C.R., Robu, V., Gerding, E.H., & Jennings, N.R. (2012).\n    IAMhaggler: A negotiation agent for complex environments. In\n    New Trends in Agent-based Complex Automated Negotiations.\n    Studies in Computational Intelligence, vol 383. Springer.', params={}, tags={'genius', 'respond', 'anac', 'propose', 'anac-2011'}, extra={}), 'IAMhaggler2012#43804459': NegotiatorInfo(key='IAMhaggler2012#43804459', short_name='IAMhaggler2012', full_type_name='negmas.genius.gnegotiators.y2012.IAMhaggler2012', cls=<class 'negmas.genius.gnegotiators.y2012.IAMhaggler2012'>, source='negmas', description='IAMhaggler2012 negotiation agent.\n\n**ANAC 2012**.\n\nAn enhanced version of IAMhaggler2011 with reservation value support\nand improved utility space handling. Developed by the University of\nSouthampton team.\n\n**Offering Strategy:**\n\n    - Inherits GP regression-based targeting from IAMhaggler2011\n    - Uses SouthamptonUtilitySpace for improved bid generation\n    - Ensures offers never fall below reservation value\n    - Falls back to initial bid if proposed bid is below reservation\n\n**Acceptance Strategy:**\n\n    - Same as IAMhaggler2011 (multiplier-based acceptance)\n    - Additional check against reservation value\n\n**Opponent Modeling:**\n\n    - Same Gaussian Process regression as IAMhaggler2011\n    - Time-slotted sampling of opponent behavior\n    - Bayesian Monte Carlo for regression updates\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Williams, C.R., Robu, V., Gerding, E.H., & Jennings, N.R. (2012).\n    IAMhaggler: A negotiation agent for complex environments. In\n    New Trends in Agent-based Complex Automated Negotiations.\n    Studies in Computational Intelligence, vol 383. Springer.', params={}, tags={'genius', 'respond', 'anac-2012', 'propose', 'anac'}, extra={}), 'IQSun2018#9a60efa6': NegotiatorInfo(key='IQSun2018#9a60efa6', short_name='IQSun2018', full_type_name='negmas.genius.gnegotiators.y2018.IQSun2018', cls=<class 'negmas.genius.gnegotiators.y2018.IQSun2018'>, source='negmas', description='IQSun2018 negotiation agent.\n\n**ANAC 2018 competitor.**\n\nWeighted average of multiple factors for utility calculation. Domain-size\ndependent weights with sinusoidal threshold variations.\n\n**Offering Strategy:**\n\n    - Combines: time-based utility, session history average, and\n      "helping bid" with sinusoidal threshold\n    - Concession factor: 0.1-0.3, minimum utility: 0.5\n    - Weights adjusted by domain size\n\n**Acceptance Strategy:**\n\n    - Accepts based on weighted combination of factors\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'Imitator#a6bcdcb7': NegotiatorInfo(key='Imitator#a6bcdcb7', short_name='Imitator', full_type_name='negmas.genius.gnegotiators.y2017.Imitator', cls=<class 'negmas.genius.gnegotiators.y2017.Imitator'>, source='negmas', description='Imitator negotiation agent.\n\n**ANAC 2017**.\n\nImitator uses frequency-based opponent modeling to generate bids that\nmatch the most frequent values offered by opponents. It aims to find\nagreements by imitating opponent preferences.\n\n**Offering Strategy:**\n\n    - Builds frequency table per issue/value from opponent offers\n    - Generates bids using the most frequent values from each opponent\n    - Compares frequencies across opponents to select optimal values\n\n**Acceptance Strategy:**\n\n    - Time-based acceptance with increasing acceptance rate\n    - More likely to accept as deadline approaches\n\n**Opponent Modeling:**\n\n    - Tracks value frequencies for each issue per opponent\n    - Compares frequencies across opponents to identify common preferences\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'ImmediateAcceptor#769e8655': NegotiatorInfo(key='ImmediateAcceptor#769e8655', short_name='ImmediateAcceptor', full_type_name='negmas.genius.gnegotiators.basic.ImmediateAcceptor', cls=<class 'negmas.genius.gnegotiators.basic.ImmediateAcceptor'>, source='negmas', description='Immediate acceptance agent.\n\nAccepts any offer immediately without negotiation. Useful as a baseline\nagent for testing or when agreement is prioritized over utility.\n\nNote:\n    AI-generated summary. May not be fully accurate.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'InoxAgent#a6ec358a': NegotiatorInfo(key='InoxAgent#a6ec358a', short_name='InoxAgent', full_type_name='negmas.genius.gnegotiators.y2013.InoxAgent', cls=<class 'negmas.genius.gnegotiators.y2013.InoxAgent'>, source='negmas', description='InoxAgent negotiation agent.\n\n**ANAC 2013**.\n\nBOA framework-based agent with custom opponent model and acceptance\nstrategy components.\n\n**Offering Strategy:**\n\n    - Uses BestBid opponent model strategy\n    - Selects bids that maximize expected opponent utility\n    - Custom InoxAgent_Offering strategy component\n\n**Acceptance Strategy:**\n\n    - AC_InoxAgent acceptance component\n    - Considers both own utility and opponent modeling predictions\n\n**Opponent Modeling:**\n\n    - InoxAgent_OM custom opponent model\n    - Frequency-based preference learning\n    - Updates model with each opponent bid\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.', params={}, tags={'genius', 'respond', 'anac-2013', 'propose', 'anac'}, extra={}), 'JonnyBlack#92441cae': NegotiatorInfo(key='JonnyBlack#92441cae', short_name='JonnyBlack', full_type_name='negmas.genius.gnegotiators.y2015.JonnyBlack', cls=<class 'negmas.genius.gnegotiators.y2015.JonnyBlack'>, source='negmas', description='JonnyBlack negotiation agent.\n\n**ANAC 2015**.\n\nEnumerates feasible bids and uses opponent preference prediction with\nround-robin fairness in multilateral scenarios.\n\n**Offering Strategy:**\n    - Enumerates all feasible bids with utility > finalStopVal (0.6)\n    - Selects bids based on estimated opponent preferences\n    - Round-robin opponent favoring: cycles agentToFavor to ensure\n      fairness in multilateral negotiations\n    - Balances own utility with opponent satisfaction\n\n**Acceptance Strategy:**\n    - Accepts bids above the minimum utility threshold (0.6)\n    - Considers opponent preferences in acceptance decision\n\n**Opponent Modeling:**\n    Frequency-based preference prediction:\n\n    - Counts value frequencies across opponent bids\n    - Estimates opponent utility function from frequency counts\n    - Uses predictions to favor bids likely acceptable to opponents\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'KAgent#3d4a65b1': NegotiatorInfo(key='KAgent#3d4a65b1', short_name='KAgent', full_type_name='negmas.genius.gnegotiators.y2019.KAgent', cls=<class 'negmas.genius.gnegotiators.y2019.KAgent'>, source='negmas', description='KAgent negotiation agent.\n\n**ANAC 2019 competitor.**\n\nBOA framework agent with preference uncertainty handling. Uses\nrandom utility space estimation and time-dependent offering with\nBoulware-like concession (e=0.01).\n\n**Offering Strategy:**\n\n    - TimeDependent_Offering with very low concession (e=0.01)\n    - Extremely Boulware-like behavior\n\n**Acceptance Strategy:**\n\n    - AC_Uncertain_Kindly: accepts with some flexibility\n\n**Opponent Modeling:**\n\n    HardHeadedFrequencyModel with BestBid OM strategy.\n\n**Preference Estimation:**\n\n    Randomized utility space (weights and values from random).\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.', params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'KGAgent#4afbcd99': NegotiatorInfo(key='KGAgent#4afbcd99', short_name='KGAgent', full_type_name='negmas.genius.gnegotiators.y2014.KGAgent', cls=<class 'negmas.genius.gnegotiators.y2014.KGAgent'>, source='negmas', description='KGAgent negotiation agent.\n\n**ANAC 2014**.\n\nGenetic algorithm optimization with opponent utility estimation.\n\n**Offering Strategy:**\n\n    - Genetic algorithm for bid optimization\n    - Time pressure adjustments for concession rate\n\n**Acceptance Strategy:**\n\n    - Accepts based on estimated mutual benefit\n    - Time-dependent threshold adaptation\n\n**Opponent Modeling:**\n\n    Estimates opponent utility from bid history for Pareto-optimal targeting.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'KakeSoba#7e85e745': NegotiatorInfo(key='KakeSoba#7e85e745', short_name='KakeSoba', full_type_name='negmas.genius.gnegotiators.y2019.KakeSoba', cls=<class 'negmas.genius.gnegotiators.y2019.KakeSoba'>, source='negmas', description='KakeSoba negotiation agent.\n\n**ANAC 2019 competitor.**\n\nUses Tabu Search for utility space estimation with Spearman rank\ncorrelation as fitness metric. Tracks bid error to minimize\ndeviation from estimated preferences.\n\n**Offering Strategy:**\n\n    - First round: offers max utility bid\n    - Later: generates bid minimizing error with utility bounds\n    - Lower bound: 0.85, upper bound: 1.0\n\n**Acceptance Strategy:**\n\n    - Accepts if bid within acceptable utility bounds (>= 0.85)\n    - Final round: accepts if better than reservation value\n\n**Preference Estimation:**\n\n    Tabu Search with 5000 movements:\n    - Random initial utility space\n    - Neighbors generated by modifying weights/values\n    - Best solution tracked via Spearman correlation score\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.', params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'Kawaii#c188e1fe': NegotiatorInfo(key='Kawaii#c188e1fe', short_name='Kawaii', full_type_name='negmas.genius.gnegotiators.y2015.Kawaii', cls=<class 'negmas.genius.gnegotiators.y2015.Kawaii'>, source='negmas', description='Kawaii negotiation agent.\n\n**ANAC 2015 Individual Utility Category Runner-up**.\n\nKawaii is a negotiation agent that uses Simulated Annealing for bid\nsearch and a time-dependent conceding strategy. It adapts its\nacceptance threshold based on the number of accepting opponents in\nmultilateral negotiations.\n\n**Offering Strategy:**\n    Uses Simulated Annealing to search for bids near the target utility:\n\n    1. First attempts relative utility search (for linear utility spaces)\n       by selecting values that sum to the target concession amount\n    2. Falls back to Simulated Annealing with parameters:\n       - Start temperature: 1.0\n       - End temperature: 0.0001\n       - Cooling rate: 0.999\n\n    The search minimizes the distance to target utility while staying\n    above it. Returns the maximum utility bid if no suitable bid found.\n\n**Acceptance Strategy:**\n    Time-dependent threshold with conceder behavior (exponent = 2):\n\n    threshold(t) = 1 - (1 - a) * t^2\n\n    where a = 0.8 is the minimum threshold.\n\n    In multilateral scenarios, the threshold is reduced based on how\n    many opponents have already accepted:\n\n    threshold -= (threshold - minThreshold) * (acceptCount / numOpponents)\n\n    This encourages acceptance when close to agreement.\n\n**Opponent Modeling:**\n    Tracks which opponents have made accepting moves (offered bids\n    close to previous offers). This information adjusts the acceptance\n    threshold to facilitate agreement when multiple parties are close\n    to consensus.\n\nReferences:\n    Baarslag, T., Aydogan, R., Hindriks, K. V., Fujita, K., Ito, T., &\n    Jonker, C. M. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine, 36(4), 115-118.', params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'Lancelot#a9580b08': NegotiatorInfo(key='Lancelot#a9580b08', short_name='Lancelot', full_type_name='negmas.genius.gnegotiators.y2018.Lancelot', cls=<class 'negmas.genius.gnegotiators.y2018.Lancelot'>, source='negmas', description='Lancelot negotiation agent.\n\n**ANAC 2018 competitor.**\n\nModular design with separate strategy and bidSearch components.\nTime-phased behavior with opponent evaluation influencing decisions.\n\n**Offering Strategy:**\n\n    - t < 0.2: random bids above threshold\n    - 0.2 <= t < 0.98: positive bids considering opponent evaluation\n    - t >= 0.98: threshold-based offers\n\n**Acceptance Strategy:**\n\n    - Opponent evaluation influences acceptance threshold\n    - More permissive near deadline\n\n**Opponent Modeling:**\n\n    Evaluates opponent behavior to adjust strategy parameters.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'Libra#4b18d8ed': NegotiatorInfo(key='Libra#4b18d8ed', short_name='Libra', full_type_name='negmas.genius.gnegotiators.y2018.Libra', cls=<class 'negmas.genius.gnegotiators.y2018.Libra'>, source='negmas', description="Libra negotiation agent.\n\n**ANAC 2018 competitor.**\n\nMeta-agent with 19 sub-agents including Boulware, Conceder, ParsAgent,\nAtlas3, YXAgent, Farma, PonPokoAgent, Rubick, etc. Uses weighted voting\non offer/accept/end decisions.\n\n**Offering Strategy:**\n\n    - Weighted voting among sub-agents' proposed offers\n    - Weights adjusted based on opponent responses to each sub-agent\n\n**Acceptance Strategy:**\n\n    - Weighted voting among sub-agents' accept/reject decisions\n\n**Opponent Modeling:**\n\n    Indirect through sub-agents. Weights reflect which sub-agent\n    strategies are most effective against current opponent.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.", params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'LimitedOutcomesAcceptor#76101698': NegotiatorInfo(key='LimitedOutcomesAcceptor#76101698', short_name='LimitedOutcomesAcceptor', full_type_name='negmas.gb.negotiators.limited.LimitedOutcomesAcceptor', cls=<class 'negmas.gb.negotiators.limited.LimitedOutcomesAcceptor'>, source='negmas', description='A negotiation agent that uses a fixed set of outcomes in a single\nnegotiation.\n\nRemarks:\n    - The ufun inputs to the constructor and join are ignored. A ufun will be generated that gives a utility equal to\n      the probability of choosing a given outcome.', params={}, tags={'builtin', 'respond', 'sao', 'limited-outcomes', 'propose'}, extra={}), 'LimitedOutcomesNegotiator#2cb83ebb': NegotiatorInfo(key='LimitedOutcomesNegotiator#2cb83ebb', short_name='LimitedOutcomesNegotiator', full_type_name='negmas.gb.negotiators.limited.LimitedOutcomesNegotiator', cls=<class 'negmas.gb.negotiators.limited.LimitedOutcomesNegotiator'>, source='negmas', description='A negotiation agent that uses a fixed set of outcomes in a single\nnegotiation.\n\nArgs:\n    acceptable_outcomes: the set of acceptable outcomes. If None then it is assumed to be all the outcomes of\n                         the negotiation.\n    acceptance_probabilities: probability of accepting each acceptable outcome. If None then it is assumed to\n                              be unity.\n    proposable_outcomes: the set of outcomes from which the agent is allowed to propose. If None, then it is\n                         the same as acceptable outcomes with nonzero probability\n    p_no_response: probability of refusing to respond to offers\n    p_ending: probability of ending negotiation\n\nRemarks:\n    - The ufun inputs to the constructor and join are ignored. A ufun will be generated that gives a utility equal to\n      the probability of choosing a given outcome.\n    - If `proposable_outcomes` is passed as None, it is considered the same as `acceptable_outcomes`', params={}, tags={'builtin', 'respond', 'sao', 'limited-outcomes', 'propose'}, extra={}), 'LinearTBNegotiator#054fc0bc': NegotiatorInfo(key='LinearTBNegotiator#054fc0bc', short_name='LinearTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.LinearTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.LinearTBNegotiator'>, source='negmas', description='A Boulware time-based negotiator that conceeds linearly', params={}, tags={'builtin', 'respond', 'sao', 'linear', 'propose', 'time-based'}, extra={}), 'MINF#cc0e9882': NegotiatorInfo(key='MINF#cc0e9882', short_name='MINF', full_type_name='negmas.genius.gnegotiators.y2019.MINF', cls=<class 'negmas.genius.gnegotiators.y2019.MINF'>, source='negmas', description="MINF negotiation agent.\n\n**ANAC 2019 competitor.**\n\nBOA framework agent with Linear Programming for utility estimation.\nUses HardHeadedFrequencyModel for opponent modeling and time-dependent\noffering with AC_Next acceptance.\n\n**Offering Strategy:**\n\n    - TimeDependent_Offering with CT (concession threshold) = 0.998\n    - Updates own bid info and opponent model info\n\n**Acceptance Strategy:**\n\n    - AC_Next: accepts if opponent's next bid would be worse\n\n**Opponent Modeling:**\n\n    HardHeadedFrequencyModel updated with opponent bids.\n    BestBid OM strategy for utilizing opponent model.\n\n**Preference Estimation:**\n\n    LP_Estimation using Linear Programming on bid ranking.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.", params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'MadAgent#d8597ce0': NegotiatorInfo(key='MadAgent#d8597ce0', short_name='MadAgent', full_type_name='negmas.genius.gnegotiators.y2017.MadAgent', cls=<class 'negmas.genius.gnegotiators.y2017.MadAgent'>, source='negmas', description='MadAgent negotiation agent.\n\n**ANAC 2017**.\n\nMadAgent uses risk-based fake bid generation and multiple opponent models.\nIt employs different "madness" phases as the deadline approaches.\n\n**Offering Strategy:**\n\n    - Generates fake bids periodically (every 100000/2^5 rounds) for risk assessment\n    - Maintains preferred bids list from opponent modeling\n    - Offers second-best bid in first 5% of negotiation\n    - Three opponent models: two individual + one combined\n\n**Acceptance Strategy:**\n\n    - Threshold starts at 0.8 * 1.125 = 0.9\n    - Adapts threshold based on opponent model predictions\n    - Time phases: "almost mad" at 50%, "mad" at 80%\n\n**Opponent Modeling:**\n\n    - Maintains three separate opponent models\n    - Tracks preferred bids per opponent\n    - Combines models for final decision making\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'Mamenchis#521f4fbf': NegotiatorInfo(key='Mamenchis#521f4fbf', short_name='Mamenchis', full_type_name='negmas.genius.gnegotiators.y2017.Mamenchis', cls=<class 'negmas.genius.gnegotiators.y2017.Mamenchis'>, source='negmas', description='Mamenchis negotiation agent.\n\n**ANAC 2017**.\n\nMamenchis uses complex time-phase bidding with social welfare optimization.\nIt aims to maximize both sum and product of utilities across parties.\n\n**Offering Strategy:**\n\n    - Time phases: time1=0.9, time2=0.99, time3=0.995\n    - History-aware parameter initialization\n    - Concession formula: upper - (upper - lower) * t^exponent\n    - Generates candidate bids by merging top bids from parties\n\n**Acceptance Strategy:**\n\n    - Phase-dependent acceptance thresholds\n    - Social welfare considerations (max sum and product of utilities)\n    - More aggressive near deadline\n\n**Opponent Modeling:**\n\n    - Preference modeling per opponent\n    - Estimates opponent utility for social welfare calculation\n    - Merges top bids to find mutually beneficial outcomes\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'MaxOops#253c502e': NegotiatorInfo(key='MaxOops#253c502e', short_name='MaxOops', full_type_name='negmas.genius.gnegotiators.y2016.MaxOops', cls=<class 'negmas.genius.gnegotiators.y2016.MaxOops'>, source='negmas', description='MaxOops negotiation agent.\n\n**ANAC 2016**.\n\nComponent-based agent by Max W. Y. Lam with TFComponent (threshold\nfunction), DMComponent (decision making), and OPTComponent modules.\n    Uses comprehensive bid statistics and hash-based bid organization.\n\n**Offering Strategy:**\n\n    - First offer: second-maximum utility bid (if gap is small, max bid)\n    - Uses DMComponent.bidProposal() for subsequent offers\n    - Organizes all possible bids in hash structure by utility (0-100)\n    - Falls back to second-max bid if proposal fails\n\n**Acceptance Strategy:**\n\n    - Immediately accepts max or second-max utility bids\n    - DMComponent.termination() decides if negotiation should end\n    - DMComponent.acceptance() decides if offer should be accepted\n    - Considers reservation value when both accept and terminate trigger\n\n**Opponent Modeling:**\n\n    Per-opponent tracking with extensive statistics:\n\n    - BidHistory for each opponent with distinct bids and accepts\n    - Tracks min/max distinct bids and accepts across opponents\n    - Updates opponent payoff weights via OPTComponent\n    - Computes domain statistics: mean, std, median, quartiles\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Aydogan, R., et al. (2017). The Seventh International Automated Negotiating\n    Agents Competition (ANAC 2016). Studies in Computational Intelligence.\n    Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'MeanBot#96d5296d': NegotiatorInfo(key='MeanBot#96d5296d', short_name='MeanBot', full_type_name='negmas.genius.gnegotiators.y2015.MeanBot', cls=<class 'negmas.genius.gnegotiators.y2015.MeanBot'>, source='negmas', description="MeanBot negotiation agent.\n\n**ANAC 2015**.\n\nExtremely simple hardball agent. Always offers maximum utility bid\nand only accepts near deadline. No opponent modeling.\n\n**Offering Strategy:**\n    - Always offers the maximum utility bid\n    - No concession throughout negotiation\n    - Pure hardball/take-it-or-leave-it approach\n\n**Acceptance Strategy:**\n    - Only considers acceptance after t >= 0.95 (95% of time elapsed)\n    - Accepts only if opponent's bid utility > 0.5\n    - Very restrictive acceptance criteria\n\n**Opponent Modeling:**\n    None. This agent ignores opponent behavior entirely.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.", params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'MeanMetaNegotiator#80667d32': NegotiatorInfo(key='MeanMetaNegotiator#80667d32', short_name='MeanMetaNegotiator', full_type_name='negmas.sao.negotiators.meta.MeanMetaNegotiator', cls=<class 'negmas.sao.negotiators.meta.MeanMetaNegotiator'>, source='negmas', description='An SAO meta-negotiator that samples outcomes around the mean utility of sub-negotiator proposals.\n\nThis negotiator collects proposals from all sub-negotiators, computes the mean utility\nof those proposals, and tries to sample an outcome with utility close to the mean.\nIf no outcome is found within a small epsilon around the mean, it progressively expands\nthe search range until it covers the full min/max range of sub-negotiator proposals.\n\nFor response aggregation, it uses majority voting among sub-negotiators.\n\nArgs:\n    negotiators: An iterable of `SAONegotiator` instances to manage. Mutually exclusive with `negotiator_types`.\n    negotiator_types: An iterable of `SAONegotiator` types to instantiate. Mutually exclusive with `negotiators`.\n    negotiator_params: Optional iterable of parameter dicts for each negotiator type. Only used with `negotiator_types`.\n    negotiator_names: Optional names for the negotiators.\n    initial_epsilon: Initial utility range around the mean to search. Defaults to 0.05.\n    epsilon_step: How much to expand the range on each iteration. Defaults to 0.1.\n    max_cardinality: Maximum number of outcomes to sample when searching. Defaults to 10000.\n    *args: Additional positional arguments passed to the base class.\n    **kwargs: Additional keyword arguments passed to the base class.\n\nExample:\n    >>> from negmas.sao.negotiators import (\n    ...     MeanMetaNegotiator,\n    ...     BoulwareTBNegotiator,\n    ...     ConcederTBNegotiator,\n    ... )\n    >>> from negmas.sao import SAOMechanism\n    >>> from negmas.preferences import LinearAdditiveUtilityFunction as U\n    >>> from negmas.outcomes import make_issue, make_os\n    >>>\n    >>> issues = [make_issue(10, "price")]\n    >>> os = make_os(issues)\n    >>> ufun1 = U.random(os, reserved_value=0.0)\n    >>> ufun2 = U.random(os, reserved_value=0.0)\n    >>>\n    >>> # Create a mean meta-negotiator with diverse strategies\n    >>> meta = MeanMetaNegotiator(\n    ...     negotiator_types=[BoulwareTBNegotiator, ConcederTBNegotiator],\n    ...     ufun=ufun1,\n    ... )\n    >>> opponent = ConcederTBNegotiator(ufun=ufun2)\n    >>>\n    >>> mechanism = SAOMechanism(issues=issues, n_steps=50)\n    >>> _ = mechanism.add(meta)\n    >>> _ = mechanism.add(opponent)\n    >>> result = mechanism.run()\n    >>> result.running\n    False', params={}, tags={'ensemble', 'builtin', 'respond', 'sao', 'meta', 'propose'}, extra={}), 'MengWan#00d93297': NegotiatorInfo(key='MengWan#00d93297', short_name='MengWan', full_type_name='negmas.genius.gnegotiators.y2018.MengWan', cls=<class 'negmas.genius.gnegotiators.y2018.MengWan'>, source='negmas', description='MengWan negotiation agent (alias for Agent36).\n\n**ANAC 2018 competitor.**\n\nSee :class:`Agent36` for full documentation.\n\nNote:\n    AI-generated summary. May not be fully accurate.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'Mercury#bbc7056d': NegotiatorInfo(key='Mercury#bbc7056d', short_name='Mercury', full_type_name='negmas.genius.gnegotiators.y2015.Mercury', cls=<class 'negmas.genius.gnegotiators.y2015.Mercury'>, source='negmas', description='Mercury negotiation agent.\n\n**ANAC 2015**.\n\nExtended version of AresParty with enhanced multi-party support.\nTracks acceptance signals and adapts offers accordingly.\n\n**Offering Strategy:**\n    - Inherits AresParty\'s discount-aware bid generation\n    - Tracks party order in multilateral negotiations\n    - When one opponent accepts (halfSucc flag), offers "nice bids"\n      in a lower utility range to close the deal\n    - Adapts strategy based on acceptance signals from opponents\n\n**Acceptance Strategy:**\n    - Similar to AresParty with discount-aware thresholds\n    - More willing to accept when close to agreement (halfSucc=true)\n\n**Opponent Modeling:**\n    Tracks acceptance signals per opponent:\n\n    - Monitors which opponents have shown willingness to accept\n    - Uses "halfSucc" flag to indicate partial agreement state\n    - Adjusts offers to facilitate final agreement\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'MetaAgent#f70895f1': NegotiatorInfo(key='MetaAgent#f70895f1', short_name='MetaAgent', full_type_name='negmas.genius.gnegotiators.y2012.MetaAgent', cls=<class 'negmas.genius.gnegotiators.y2012.MetaAgent'>, source='negmas', description='MetaAgent negotiation agent.\n\n**ANAC 2012**.\n\nA meta-level agent that dynamically selects from a pool of existing\nnegotiation agents based on domain characteristics. Uses regression\nmodels to predict which agent will perform best.\n\n**Agent Selection:**\n\n    - Analyzes domain: issues, discount factor, domain size,\n      expected utility, standard deviations\n    - Uses pre-trained regression coefficients for 18 candidate agents\n    - Applies Quantal Response Equilibrium (QRE) for probabilistic selection\n    - Candidate pool includes winners from ANAC 2010-2011\n\n**Offering Strategy:**\n\n    - First bid: always offers maximum utility bid\n    - Subsequent bids: delegated to selected agent\n    - Handles reservation value (ends negotiation if offer below)\n\n**Candidate Agents:**\n\n    HardHeaded, AgentK2, TheNegotiator, ValueModelAgent, Gahboninho,\n    BRAMAgent, AgentSmith, and several custom agents (Chameleon,\n    WinnerAgent, GYRL, DNAgent, etc.)\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.', params={}, tags={'genius', 'respond', 'anac-2012', 'propose', 'anac'}, extra={}), 'MetaAgent2012#5350e013': NegotiatorInfo(key='MetaAgent2012#5350e013', short_name='MetaAgent2012', full_type_name='negmas.genius.gnegotiators.y2012.MetaAgent2012', cls=<class 'negmas.genius.gnegotiators.y2012.MetaAgent2012'>, source='negmas', description='MetaAgent2012 negotiation agent.\n\n**ANAC 2012**.\n\nIdentical to MetaAgent - this is an alias wrapper pointing to the same\nJava implementation (agents.anac.y2012.MetaAgent.MetaAgent).\n\nSee MetaAgent for full documentation of the strategy.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.', params={}, tags={'genius', 'respond', 'anac-2012', 'propose', 'anac'}, extra={}), 'MetaAgent2013#23b11978': NegotiatorInfo(key='MetaAgent2013#23b11978', short_name='MetaAgent2013', full_type_name='negmas.genius.gnegotiators.y2013.MetaAgent2013', cls=<class 'negmas.genius.gnegotiators.y2013.MetaAgent2013'>, source='negmas', description='MetaAgent2013 negotiation agent.\n\n**ANAC 2013**.\n\nMeta-level agent that selects the best negotiation strategy from a pool\nof agents based on domain features. Uses regression-based prediction\nto choose optimal agent for each negotiation context.\n\n**Agent Selection:**\n\n    - Extracts domain features: number of issues, issue sizes, utilities\n    - Considers discount factor and reservation value\n    - Uses AgentManager for regression-based agent selection\n    - Persists results across sessions for learning\n\n**Strategy:**\n\n    - Delegates all negotiation to selected sub-agent\n    - Selection made at negotiation start based on domain analysis\n    - Stores performance data for future agent selection improvement\n\n**Learning:**\n\n    - Maintains persistent data across negotiation sessions\n    - Updates regression model with outcomes\n    - Improves agent selection over time\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Mbarki, M., & Larson, K. (2013). An adaptive meta-agent for negotiation.\n    In: *AAMAS Workshop on Automated Negotiating Agents*.', params={}, tags={'genius', 'respond', 'anac-2013', 'propose', 'anac'}, extra={}), 'MiCRONegotiator#19166640': NegotiatorInfo(key='MiCRONegotiator#19166640', short_name='MiCRONegotiator', full_type_name='negmas.gb.negotiators.micro.MiCRONegotiator', cls=<class 'negmas.gb.negotiators.micro.MiCRONegotiator'>, source='negmas', description='Rational Concession Negotiator\n\nArgs:\n     name: Negotiator name\n     parent: Parent controller if any\n     preferences: The preferences of the negotiator\n     ufun: The ufun of the negotiator (overrides prefrences)\n     owner: The `Agent` that owns the negotiator.', params={}, tags={'builtin', 'respond', 'sao', 'learning', 'propose', 'micro'}, extra={}), 'Mosa#91a2997d': NegotiatorInfo(key='Mosa#91a2997d', short_name='Mosa', full_type_name='negmas.genius.gnegotiators.y2017.Mosa', cls=<class 'negmas.genius.gnegotiators.y2017.Mosa'>, source='negmas', description='Mosa negotiation agent.\n\n**ANAC 2017**.\n\nMosa is very similar to Mamenchis (same team) with slightly different\nparameters. Uses time-phase bidding with social welfare optimization.\n\n**Offering Strategy:**\n\n    - Time phases: 0.9, 0.99, 0.996\n    - Initial upper=0.95, exponent=50\n    - Same social welfare approach as Mamenchis\n    - Slightly different tuning parameters\n\n**Acceptance Strategy:**\n\n    - Phase-dependent acceptance with social welfare consideration\n    - Similar to Mamenchis with parameter variations\n\n**Opponent Modeling:**\n\n    - Same preference modeling approach as Mamenchis\n    - Estimates opponent utilities for welfare calculations\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'MyAgent#44893fa5': NegotiatorInfo(key='MyAgent#44893fa5', short_name='MyAgent', full_type_name='negmas.genius.gnegotiators.y2016.MyAgent', cls=<class 'negmas.genius.gnegotiators.y2016.MyAgent'>, source='negmas', description='MyAgent negotiation agent.\n\n**ANAC 2016**.\n\nModular agent similar to AgentSmith2016 with negotiationInfo, bidSearch,\nand negotiationStrategy components. Uses slant analysis for opponent\n    modeling and tracks issue weights per opponent.\n\n**Offering Strategy:**\n\n    - Uses time-dependent threshold from negotiationStrategy\n    - Generates bids via bidSearch with random seed\n    - Tracks own bid history for consistency\n\n**Acceptance Strategy:**\n\n    - Time-dependent threshold-based acceptance\n    - May terminate negotiation based on time conditions\n    - Updates "last" flag to track recent actions\n\n**Opponent Modeling:**\n\n    Per-opponent tracking including:\n\n    - Issue weight estimation updated on each offer\n    - Accept list tracking which bids each opponent accepts\n    - Slant analysis for predicting opponent behavior\n    - Recent weight and max weight calculations\n    - Maximum value tracking per opponent\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Aydogan, R., et al. (2017). The Seventh International Automated Negotiating\n    Agents Competition (ANAC 2016). Studies in Computational Intelligence.\n    Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'NaiveTitForTatNegotiator#e2d0fd91': NegotiatorInfo(key='NaiveTitForTatNegotiator#e2d0fd91', short_name='NaiveTitForTatNegotiator', full_type_name='negmas.gb.negotiators.titfortat.NaiveTitForTatNegotiator', cls=<class 'negmas.gb.negotiators.titfortat.NaiveTitForTatNegotiator'>, source='negmas', description="Implements a naive tit-for-tat strategy that does not depend on the availability of an opponent model.\n\nArgs:\n    name: Negotiator name\n    preferences: negotiator preferences\n    ufun: negotiator ufun (overrides preferences)\n    parent: A controller\n    kindness: How 'kind' is the agent. A value of zero is standard tit-for-tat. Positive values makes the negotiator\n              concede faster and negative values slower.\n    stochastic: If `True`, the offers will be randomized above the level determined by the current concession\n                    which in turn reflects the opponent's concession.\n    punish: If `True` the agent punish a partner who does not seem to conede by requiring higher utilities\n    initial_concession: How much should the agent concede in the beginning in terms of utility. Should be a number\n                        or the special string value 'min' for minimum concession\n\nRemarks:\n\n    - This negotiator does not keep an opponent model. It thinks only in terms of changes in its own utility.\n      If the opponent's last offer was better for the negotiator compared with the one before it, it considers\n      that the opponent has conceded by the difference. This means that it implicitly assumes a zero-sum\n      situation.", params={}, tags={'tit-for-tat', 'builtin', 'respond', 'sao', 'propose'}, extra={}), 'Ngent#9d5ba6a0': NegotiatorInfo(key='Ngent#9d5ba6a0', short_name='Ngent', full_type_name='negmas.genius.gnegotiators.y2016.Ngent', cls=<class 'negmas.genius.gnegotiators.y2016.Ngent'>, source='negmas', description="Ngent negotiation agent.\n\n**ANAC 2016**.\n\nDeveloped by Tom and Tommy. Uses 3D space bid search to find Nash-like\noutcomes by minimizing distance to all parties' preferences. Features\n    adaptive minimum utility thresholds and time-interval based concession.\n\n**Offering Strategy:**\n\n    - First round: offers maximum utility bid\n    - Searches bids in 3D space (own utility, opponent1 score, opponent2 score)\n    - Selects bid minimizing squared distance to (1,1,1) point\n    - Limits search to max 7000 bids for large domains\n    - Uses log frequency for domains > 1000 bids, otherwise raw frequency\n\n**Acceptance Strategy:**\n\n    - Accepts if utility >= average threshold or >= next round's utility\n    - Compares discounted current maximum to predicted maximum\n    - In final rounds (t > 0.99): accepts if utility > average threshold\n    - May concede to opponent's best historical bid if conditions met\n\n**Opponent Modeling:**\n\n    Separate AgentData for each opponent with:\n\n    - Issue scoring using exponential decay (e^-t for additions)\n    - Tracks utility maximums across three time sessions\n    - Concession degree updates based on time intervals\n    - Adaptive minimum utility calculation (different for small/large DF)\n    - k parameter scales with domain size (1-4)\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Aydogan, R., et al. (2017). The Seventh International Automated Negotiating\n    Agents Competition (ANAC 2016). Studies in Computational Intelligence.\n    Springer, Cham.", params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'NiceNegotiator#4e5d3839': NegotiatorInfo(key='NiceNegotiator#4e5d3839', short_name='NiceNegotiator', full_type_name='negmas.gb.negotiators.nice.NiceNegotiator', cls=<class 'negmas.gb.negotiators.nice.NiceNegotiator'>, source='negmas', description='Offers and accepts anything.\n\nArgs:\n     name: Negotiator name\n     parent: Parent controller if any\n     preferences: The preferences of the negotiator\n     ufun: The ufun of the negotiator (overrides prefrences)\n     owner: The `Agent` that owns the negotiator.', params={}, tags={'builtin', 'respond', 'sao', 'propose', 'aspiration'}, extra={}), 'NiceTitForTat#2881686f': NegotiatorInfo(key='NiceTitForTat#2881686f', short_name='NiceTitForTat', full_type_name='negmas.genius.gnegotiators.y2011.NiceTitForTat', cls=<class 'negmas.genius.gnegotiators.y2011.NiceTitForTat'>, source='negmas', description="NiceTitForTat negotiation agent.\n\nNiceTitForTat (developed by Tim Baarslag) implements a cooperative\ntit-for-tat strategy with respect to utility space, aiming for the\nNash bargaining solution.\n\n**Offering Strategy:**\n\n    - Initially cooperates with high utility bids\n    - Responds in kind to opponent's concessions\n    - Calculates opponent's concession factor relative to Nash point\n    - Mirrors opponent's concession proportionally\n    - Time bonus near deadline to encourage agreement\n    - Selects bids that maximize opponent utility among equivalents\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent's offer >= planned counter-offer utility\n    - Near deadline: probabilistic acceptance based on expected utility\n      of waiting for better offers\n    - Considers recent bid history to estimate probability of improvement\n\n**Opponent Modeling:**\n\n    Bayesian opponent model that:\n\n    - Updates beliefs about opponent preferences after each bid\n    - Estimates opponent's utility function\n    - Used to find Nash point and select opponent-favorable bids\n    - Guides concession strategy to match opponent's behavior\n\nReferences:\n\n    Baarslag, T., Hindriks, K., & Jonker, C. (2013). A tit for tat\n    negotiation strategy for real-time bilateral negotiations.\n    Studies in Computational Intelligence, 435:229-233.", params={}, tags={'genius', 'respond', 'anac', 'propose', 'anac-2011'}, extra={}), 'Nozomi#d9878a81': NegotiatorInfo(key='Nozomi#d9878a81', short_name='Nozomi', full_type_name='negmas.genius.gnegotiators.y2010.Nozomi', cls=<class 'negmas.genius.gnegotiators.y2010.Nozomi'>, source='negmas', description='Nozomi negotiation agent.\n\n**ANAC 2010 Finalist**.\n\nNozomi uses a sophisticated multi-strategy approach with adaptive behavior\nbased on opponent responsiveness and negotiation progress.\n\n**Offering Strategy:**\n\n    - Starts with maximum utility bid\n    - Uses four bid types selected probabilistically:\n        - COMPROMISE: Incrementally concede on one issue toward opponent\'s position\n        - KEEP: Repeat previous bid to signal firmness\n        - APPROACH: Move closer to opponent on multiple issues\n        - RESTORE: Return to a saved "restore bid" (best bid close to opponent)\n    - Maintains dynamic minimum utility threshold (maxCompromiseUtility)\n    - Adapts concession based on opponent\'s reciprocity\n\n**Acceptance Strategy:**\n\n    - Accepts if utility > 95% of maximum utility\n    - Accepts if opponent\'s offer ≥ own previous bid\'s utility\n    - Time-dependent acceptance with multiple phases:\n        - t < 0.5: Accept good offers with strict utility threshold\n        - 0.5 ≤ t < 0.8: Slightly more lenient acceptance\n        - t ≥ 0.8: Accept if close to restore bid or previous position\n    - Uses "evaluation gap" to measure bid similarity\n\n**Opponent Modeling:**\n\n    Behavioral tracking approach:\n\n    - Tracks opponent\'s best offer and updates maximum aspiration accordingly\n    - Monitors opponent\'s concession patterns (continuous compromise tracking)\n    - Detects if opponent is compromising and adjusts own strategy\n    - Updates "restore bid" to track bids closest to opponent\'s best offer\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Baarslag, T., Hindriks, K., Hendrikx, M., Dirkzwager, A., & Jonker, C.M. (2014).\n    Decoupling Negotiating Agents to Explore the Space of Negotiation Strategies.\n    In Novel Insights in Agent-based Complex Automated Negotiation.\n    Studies in Computational Intelligence, vol 535. Springer.', params={}, tags={'genius', 'anac-2010', 'respond', 'propose', 'anac'}, extra={}), 'OMACagent#13064bf7': NegotiatorInfo(key='OMACagent#13064bf7', short_name='OMACagent', full_type_name='negmas.genius.gnegotiators.y2012.OMACagent', cls=<class 'negmas.genius.gnegotiators.y2012.OMACagent'>, source='negmas', description="OMACagent negotiation agent.\n\n**ANAC 2012**.\n\nOpponent Modeling and Adaptive Concession agent developed at Maastricht\nUniversity. Uses time-series forecasting to predict opponent behavior\nand adapt concession strategy accordingly.\n\n**Offering Strategy:**\n\n    - Early phase (t <= 0.02): offers maximum utility bid\n    - Uses exponential moving average (EMA) forecasting of opponent bids\n    - Generates random bids within utility range [target±1%]\n    - Adjusts target based on forecast vs original concession curve\n    - Different parameters for high vs low discount factor domains\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent offer >= own planned offer utility\n    - Accepts if bid was previously in own bid history\n    - Near deadline: accepts best opponent bid if above minimum (0.59)\n    - Ends negotiation if no acceptable bid found and reservation > 0\n\n**Opponent Modeling:**\n\n    Time-series prediction using:\n\n    - Moving average of opponent's max utilities per time block\n    - Residual analysis with standard deviation\n    - Forecasts next time slot's expected opponent utility\n    - Adapts concession curve to match/beat forecast\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Chen, S., & Weiss, G. (2012). An Efficient and Adaptive Approach to\n    Negotiation in Complex Environments. In ECAI 2012.", params={}, tags={'genius', 'respond', 'anac-2012', 'propose', 'anac'}, extra={}), 'OSMeanMetaNegotiator#be357c60': NegotiatorInfo(key='OSMeanMetaNegotiator#be357c60', short_name='OSMeanMetaNegotiator', full_type_name='negmas.sao.negotiators.meta.OSMeanMetaNegotiator', cls=<class 'negmas.sao.negotiators.meta.OSMeanMetaNegotiator'>, source='negmas', description='An SAO meta-negotiator that aggregates proposals by averaging in outcome space.\n\nUnlike `MeanMetaNegotiator` which works in utility space, this negotiator works\ndirectly in the outcome space by averaging issue values from sub-negotiator proposals.\n\nFor numeric issues (integers, floats), it computes the mean value across all\nsub-negotiator proposals and finds/generates an outcome with values near that mean.\nFor non-numeric issues (categorical), it samples from the values proposed by\nsub-negotiators.\n\nFor response aggregation, it uses majority voting among sub-negotiators.\n\nArgs:\n    negotiators: An iterable of `SAONegotiator` instances to manage. Mutually exclusive with `negotiator_types`.\n    negotiator_types: An iterable of `SAONegotiator` types to instantiate. Mutually exclusive with `negotiators`.\n    negotiator_params: Optional iterable of parameter dicts for each negotiator type. Only used with `negotiator_types`.\n    negotiator_names: Optional names for the negotiators.\n    *args: Additional positional arguments passed to the base class.\n    **kwargs: Additional keyword arguments passed to the base class.\n\nRemarks:\n    - For continuous issues, the mean value is used directly.\n    - For discrete numeric issues (integers), the mean is rounded to the nearest\n      valid value within the issue\'s range.\n    - For categorical issues, a value is randomly sampled from those proposed\n      by the sub-negotiators.\n\nExample:\n    >>> from negmas.sao.negotiators import (\n    ...     OSMeanMetaNegotiator,\n    ...     BoulwareTBNegotiator,\n    ...     ConcederTBNegotiator,\n    ... )\n    >>> from negmas.sao import SAOMechanism\n    >>> from negmas.preferences import LinearAdditiveUtilityFunction as U\n    >>> from negmas.outcomes import make_issue, make_os\n    >>>\n    >>> issues = [make_issue(10, "price"), make_issue(5, "quantity")]\n    >>> os = make_os(issues)\n    >>> ufun1 = U.random(os, reserved_value=0.0)\n    >>> ufun2 = U.random(os, reserved_value=0.0)\n    >>>\n    >>> # Create an outcome-space mean meta-negotiator\n    >>> meta = OSMeanMetaNegotiator(\n    ...     negotiator_types=[BoulwareTBNegotiator, ConcederTBNegotiator],\n    ...     ufun=ufun1,\n    ... )\n    >>> opponent = ConcederTBNegotiator(ufun=ufun2)\n    >>>\n    >>> mechanism = SAOMechanism(issues=issues, n_steps=50)\n    >>> _ = mechanism.add(meta)\n    >>> _ = mechanism.add(opponent)\n    >>> result = mechanism.run()\n    >>> result.running\n    False', params={}, tags={'ensemble', 'builtin', 'respond', 'sao', 'meta', 'propose'}, extra={}), 'OptimalBidderSimple#7f23712e': NegotiatorInfo(key='OptimalBidderSimple#7f23712e', short_name='OptimalBidderSimple', full_type_name='negmas.genius.gnegotiators.basic.OptimalBidderSimple', cls=<class 'negmas.genius.gnegotiators.basic.OptimalBidderSimple'>, source='negmas', description='Simple optimal bidding agent.\n\nSearches for optimal bids by evaluating offers based on own utility\nfunction. Uses a straightforward approach to find high-utility offers\nwithout complex opponent modeling.\n\nNote:\n    AI-generated summary. May not be fully accurate.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'PNegotiator#a61d3b97': NegotiatorInfo(key='PNegotiator#a61d3b97', short_name='PNegotiator', full_type_name='negmas.genius.gnegotiators.y2015.PNegotiator', cls=<class 'negmas.genius.gnegotiators.y2015.PNegotiator'>, source='negmas', description='PNegotiator negotiation agent.\n\n**ANAC 2015**.\n\nTwo-state agent (HARDLINER/CONCEDER) with Bayesian opponent modeling\nusing the BayesLogic class for preference estimation.\n\n**Offering Strategy:**\n    Two distinct phases:\n\n    - HARDLINER (t < 0.2): Offers maximum utility bids, no concession\n    - CONCEDER (t >= 0.2): Gradual concession using formula:\n      utility = (maxUtil - Cj/numIssues)² where Cj = maxUtil * t²\n\n**Acceptance Strategy:**\n    - In HARDLINER phase: only accepts very high utility bids\n    - In CONCEDER phase: accepts based on calculated concession utility\n\n**Opponent Modeling:**\n    Bayesian opponent modeling via BayesLogic class:\n\n    - Maintains probability distributions over opponent preferences\n    - Updates beliefs based on observed bids\n    - Uses Bayesian inference for preference estimation\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'ParsAgent#f877cd0f': NegotiatorInfo(key='ParsAgent#f877cd0f', short_name='ParsAgent', full_type_name='negmas.genius.gnegotiators.y2015.ParsAgent', cls=<class 'negmas.genius.gnegotiators.y2015.ParsAgent'>, source='negmas', description="ParsAgent negotiation agent.\n\n**ANAC 2015 Individual Utility Category Finalist**.\n\nParsAgent by Zahra Khosravimehr from Amirkabir University of Technology\nuses a hybrid bidding strategy combining time-dependent, random, and\nfrequency-based approaches to propose high-utility offers close to\nopponent preferences, increasing the likelihood of early agreement.\n\n**Offering Strategy:**\n    Employs a multi-step bid generation process:\n\n    1. First checks if there's a mutually beneficial bid from the\n       intersection of both opponents' preferences (in multilateral).\n    2. If not found, constructs a bid using:\n       - Mutual issue values (agreed by both opponents based on frequency)\n       - Own best values for non-mutual issues\n    3. Falls back to modifying the best bid on the worst-weighted issue\n\n    Target utility follows Boulware-style concession:\n\n    target(t) = 1 - t^(1/e)\n\n    where e = 0.15 (or 0.2 with discount factor). Minimum threshold is 0.7.\n\n**Acceptance Strategy:**\n    Simple time-dependent acceptance: accepts if opponent's offer\n    utility exceeds the target utility at current time. The target\n    decreases from 1.0 towards 0.7 following the Boulware curve.\n\n**Opponent Modeling:**\n    Frequency-based modeling for each opponent:\n\n    - Tracks repeated values for each issue across opponent bids\n    - Identifies mutual preferences between opponents (values both\n      opponents frequently request)\n    - Maintains sorted list of opponent bids by utility\n    - Searches for Nash-like outcomes using common preferences\n\nReferences:\n    Khosravimehr, Z., & Nassiri-Mofakham, F. (2017). Pars Agent: Hybrid\n    Time-Dependent, Random and Frequency-Based Bidding and Acceptance\n    Strategies in Multilateral Negotiations. In Fujita, K., et al.\n    Modern Approaches to Agent-based Complex Automated Negotiation.\n    Studies in Computational Intelligence, vol 674. Springer, Cham.", params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'ParsAgent2#ad92abb4': NegotiatorInfo(key='ParsAgent2#ad92abb4', short_name='ParsAgent2', full_type_name='negmas.genius.gnegotiators.y2016.ParsAgent2', cls=<class 'negmas.genius.gnegotiators.y2016.ParsAgent2'>, source='negmas', description='ParsAgent2 negotiation agent.\n\n**ANAC 2016**.\n\nEvolution of ParsAgent using k-means clustering (k=3) for opponent modeling.\nExtends AbstractTimeDependentNegotiationParty with adaptive concession\n    rate based on cluster analysis.\n\n**Offering Strategy:**\n\n    - Time-dependent target utility with adaptive concession rate\n    - Identifies mutual issues between opponents for bid construction\n    - Uses getNNBid to find nearest neighbor bid from accepted history\n    - In final rounds: may offer best mutual cluster center\n\n**Acceptance Strategy:**\n\n    - Accepts if offered utility >= target utility\n    - Target utility never drops below ConstantUtility (default 0.8)\n    - Near deadline: adjusts constant utility based on remaining rounds\n    - Uses probability function to evaluate bid acceptance likelihood\n\n**Opponent Modeling:**\n\n    K-means clustering (k=3) per opponent:\n\n    - Clusters opponent bids every N rounds (slotNum=100)\n    - Tracks cluster history with center movements\n    - Calculates distribution factor (deviation from uniform)\n    - Computes concession rate from cluster analysis:\n      w1*maxCenterDistance + w2*meanDistance - w3*meanDistribution\n    - Identifies mutual issues across both opponents\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Aydogan, R., et al. (2017). The Seventh International Automated Negotiating\n    Agents Competition (ANAC 2016). Studies in Computational Intelligence.\n    Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'ParsAgent3#454b5a0b': NegotiatorInfo(key='ParsAgent3#454b5a0b', short_name='ParsAgent3', full_type_name='negmas.genius.gnegotiators.y2017.ParsAgent3', cls=<class 'negmas.genius.gnegotiators.y2017.ParsAgent3'>, source='negmas', description='ParsAgent3 negotiation agent.\n\n**ANAC 2017**.\n\nAlias for ShahAgent. Uses the same Java class (agents.anac.y2017.parsagent3.ShahAgent).\nSee :class:`ShahAgent` for full documentation.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'ParsCat#4cf54128': NegotiatorInfo(key='ParsCat#4cf54128', short_name='ParsCat', full_type_name='negmas.genius.gnegotiators.y2016.ParsCat', cls=<class 'negmas.genius.gnegotiators.y2016.ParsCat'>, source='negmas', description="ParsCat negotiation agent.\n\n**ANAC 2016 Individual Utility Category Runner-up**.\n\nParsCatAgent is developed by Amirkabir University of Technology and uses\na time-dependent bidding strategy with a complex piecewise acceptance\nfunction. The agent maintains a history of opponent bids and uses\ntime-based thresholds that vary across different negotiation phases.\n\n**Offering Strategy:**\n\n    The agent generates random bids within a narrow utility window around\n    a time-varying threshold. The threshold decreases over time but with\n    different rates across negotiation phases:\n\n    - t < 0.5: threshold = 1.0 - t/4 (slow concession)\n    - 0.5 <= t < 0.8: threshold = 0.9 - t/5\n    - 0.8 <= t < 0.9: threshold = 0.7 + t/5 (strategic increase)\n    - 0.9 <= t < 0.95: threshold = 0.8 + t/5\n    - t >= 0.95: threshold = 1.0 - t/4 - 0.01\n\n    The search window around the threshold is typically +/- 0.01 to 0.02.\n    If the best opponent bid has higher utility than the generated bid\n    (in bilateral negotiations), it returns the opponent's best bid.\n\n**Acceptance Strategy:**\n\n    Uses a complex piecewise function based on negotiation time with 10\n    distinct phases, creating an oscillating acceptance threshold:\n\n    - Starts high (1.0), drops to ~0.9 by t=0.25\n    - Oscillates between 0.7-1.0 through mid-game\n    - Ends around 0.5-0.7 in the final phase\n\n    This non-monotonic pattern makes the agent's behavior harder to\n    predict and exploit.\n\n**Opponent Modeling:**\n\n    Maintains a history of opponent bids with utilities and timestamps.\n    Uses the best bid from opponent history as a fallback offer when\n    the generated bid has lower utility.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.", params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'ParsCat2#38e51124': NegotiatorInfo(key='ParsCat2#38e51124', short_name='ParsCat2', full_type_name='negmas.genius.gnegotiators.y2016.ParsCat2', cls=<class 'negmas.genius.gnegotiators.y2016.ParsCat2'>, source='negmas', description='ParsCat2 negotiation agent.\n\n**ANAC 2016**.\n\nAlias for ParsCat agent - uses the same underlying Java implementation.\nSee ParsCat for full documentation of the strategy.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Aydogan, R., et al. (2017). The Seventh International Automated Negotiating\n    Agents Competition (ANAC 2016). Studies in Computational Intelligence.\n    Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'PhoenixParty#1b96ce93': NegotiatorInfo(key='PhoenixParty#1b96ce93', short_name='PhoenixParty', full_type_name='negmas.genius.gnegotiators.y2015.PhoenixParty', cls=<class 'negmas.genius.gnegotiators.y2015.PhoenixParty'>, source='negmas', description='PhoenixParty negotiation agent.\n\n**ANAC 2015**.\n\nAdvanced agent using Gaussian Process regression for opponent modeling\nto predict opponent concession behavior. Features complex parameter tuning.\n\n**Offering Strategy:**\n    - Uses Gaussian Process predictions for opponent concession timing\n    - Complex parameter set (alpha, beta, omega, epsilon, xi, gamma)\n      for fine-tuned strategy control\n    - Frequency-based heuristic ranking of bids\n    - Discount-aware with reservation value checks\n\n**Acceptance Strategy:**\n    - Accepts based on predicted opponent behavior from GP model\n    - Checks against reservation value considering discount factor\n    - Uses multiple parameters to balance acceptance criteria\n\n**Opponent Modeling:**\n    Gaussian Process (GP) regression - unique among ANAC 2015 agents:\n\n    - Models opponent concession as a function over time\n    - Predicts future opponent utility targets\n    - Uncertainty quantification in predictions\n    - Combined with frequency-based heuristic ranking\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'PodAgent#7b54aab4': NegotiatorInfo(key='PodAgent#7b54aab4', short_name='PodAgent', full_type_name='negmas.genius.gnegotiators.y2019.PodAgent', cls=<class 'negmas.genius.gnegotiators.y2019.PodAgent'>, source='negmas', description='PodAgent negotiation agent (alias for Group1BOA).\n\n**ANAC 2019 competitor.**\n\nSee :class:`Group1BOA` for full documentation.\n\nNote:\n    AI-generated summary. May not be fully accurate.', params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'PokerFace#056f8360': NegotiatorInfo(key='PokerFace#056f8360', short_name='PokerFace', full_type_name='negmas.genius.gnegotiators.y2015.PokerFace', cls=<class 'negmas.genius.gnegotiators.y2015.PokerFace'>, source='negmas', description='PokerFace negotiation agent.\n\n**ANAC 2015**.\n\nTwo-phase strategy: random walking among high-utility bids early,\nthen concedes based on opponent bid frequency analysis.\n\n**Offering Strategy:**\n    Two phases:\n\n    - Early phase (t < 0.6): Random walker selecting among high-utility\n      bids (utility > 0.85) to avoid revealing preferences\n    - Late phase (t >= 0.6): Concedes using opponent bid frequency\n      analysis with binary concede bid generation\n\n**Acceptance Strategy:**\n    - Early phase: strict, only accepts very high utility\n    - Late phase: uses moving average for time estimation\n    - More lenient acceptance as deadline approaches\n\n**Opponent Modeling:**\n    Frequency analysis of opponent bids:\n\n    - Tracks bid frequencies over negotiation history\n    - Uses moving average to estimate time per round\n    - Analyzes opponent patterns to guide concession\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'PonPokoAgent#c28d06f8': NegotiatorInfo(key='PonPokoAgent#c28d06f8', short_name='PonPokoAgent', full_type_name='negmas.genius.gnegotiators.y2017.PonPokoAgent', cls=<class 'negmas.genius.gnegotiators.y2017.PonPokoAgent'>, source='negmas', description="PonPokoAgent negotiation agent.\n\n**ANAC 2017 Individual Utility Category Winner**.\n\nPonPokoAgent by Takaki Matsune employs a randomized multi-strategy approach\nthat makes it difficult for opponents to predict its behavior. At the start\nof each negotiation session, it randomly selects one of 5 different bidding\npatterns, each with distinct concession characteristics.\n\n**Offering Strategy:**\n\n    The agent randomly selects one of 5 bidding patterns at initialization:\n\n    - **Pattern 0**: Sinusoidal oscillation with slow linear decline.\n      High/Low thresholds follow sin(40t) pattern.\n    - **Pattern 1**: Linear concession from 1.0, slow decline to 0.78.\n    - **Pattern 2**: Sinusoidal with larger amplitude (sin(20t)).\n    - **Pattern 3**: Very conservative, minimal concession (0.95-1.0)\n      until deadline when it drops to 0.7.\n    - **Pattern 4**: Sinusoidal pattern tied to time (sin(20t) * t).\n\n    Bids are selected from the pre-sorted bid space within the\n    [threshold_low, threshold_high] utility range.\n\n**Acceptance Strategy:**\n\n    Accepts if the opponent's offer has utility greater than the current\n    threshold_low value. This creates a simple but effective acceptance\n    criterion that varies with the selected bidding pattern.\n\n**Opponent Modeling:**\n\n    PonPokoAgent does not employ explicit opponent modeling. Its strength\n    lies in the unpredictability of its randomly selected strategy, making\n    it resistant to exploitation by adaptive opponents.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.", params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'PonPokoRampage#b35a6da1': NegotiatorInfo(key='PonPokoRampage#b35a6da1', short_name='PonPokoRampage', full_type_name='negmas.genius.gnegotiators.y2018.PonPokoRampage', cls=<class 'negmas.genius.gnegotiators.y2018.PonPokoRampage'>, source='negmas', description='PonPokoRampage negotiation agent.\n\n**ANAC 2018 competitor.**\n\nExtension of PonPokoAgent with 5 random threshold patterns. Detects\n"hardliner" opponents and adjusts strategy accordingly.\n\n**Offering Strategy:**\n\n    - Sinusoidal threshold variations with random pattern selection\n    - Adjusts threshold +0.05 if hardliner opponent detected\n\n**Acceptance Strategy:**\n\n    - Uses threshold modified by opponent hardliner detection\n\n**Opponent Modeling:**\n\n    Detects hardliner opponents by counting unique bids offered.\n    Few unique bids indicates a hardliner.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'Q12015Group2#737a9f0e': NegotiatorInfo(key='Q12015Group2#737a9f0e', short_name='Q12015Group2', full_type_name='negmas.genius.gnegotiators.others.Q12015Group2', cls=<class 'negmas.genius.gnegotiators.others.Q12015Group2'>, source='negmas', description="TU Delft IN4010 Q1 2015 Group 2 negotiation agent.\n\nStudent project agent from TU Delft's IN4010 Multi-Agent Systems course\n(Q1 2015). Implements a negotiation strategy developed as part of coursework.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n    Student project - no published reference available.", params={}, tags={'genius', 'respond', 'propose', 'tudelft'}, extra={}), 'RandomAlwaysAcceptingNegotiator#487bc5a9': NegotiatorInfo(key='RandomAlwaysAcceptingNegotiator#487bc5a9', short_name='RandomAlwaysAcceptingNegotiator', full_type_name='negmas.gb.negotiators.randneg.RandomAlwaysAcceptingNegotiator', cls=<class 'negmas.gb.negotiators.randneg.RandomAlwaysAcceptingNegotiator'>, source='negmas', description='RandomAlwaysAccepting negotiator.', params={}, tags={'builtin', 'respond', 'random', 'sao', 'propose'}, extra={}), 'RandomCounterOfferNegotiationParty#95618917': NegotiatorInfo(key='RandomCounterOfferNegotiationParty#95618917', short_name='RandomCounterOfferNegotiationParty', full_type_name='negmas.genius.gnegotiators.basic.RandomCounterOfferNegotiationParty', cls=<class 'negmas.genius.gnegotiators.basic.RandomCounterOfferNegotiationParty'>, source='negmas', description='Random counter-offer negotiation agent.\n\nGenerates random counter-offers from the outcome space. Accepts offers\nabove a certain utility threshold. Useful as a baseline for comparing\nmore sophisticated strategies.\n\nNote:\n    AI-generated summary. May not be fully accurate.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'RandomDance#e8a1335f': NegotiatorInfo(key='RandomDance#e8a1335f', short_name='RandomDance', full_type_name='negmas.genius.gnegotiators.y2015.RandomDance', cls=<class 'negmas.genius.gnegotiators.y2015.RandomDance'>, source='negmas', description="RandomDance negotiation agent.\n\n**ANAC 2015 Individual Utility Category Finalist**.\n\nRandomDance Agent by Shinji Kakimoto proposes an opponent modeling\napproach using multiple weighted utility estimation functions. The\nagent randomly selects among different weighting schemes, making it\nunpredictable while still being responsive to opponent behavior.\n\n**Offering Strategy:**\n    Searches for bids that balance self-utility with estimated opponent\n    utility using weighted combination:\n\n    1. For each issue, selects values that maximize weighted sum of\n       estimated utilities across all parties\n    2. Adjusts own weight iteratively (0 to 10) until finding a bid\n       above the target utility\n    3. Target utility is adaptive: starts at estimated Nash point and\n       decreases following t^discount curve\n\n    Falls back to best bid if no suitable bid found.\n\n**Acceptance Strategy:**\n    Accepts based on target utility comparison with safety margin:\n\n    - Tracks time per round to estimate remaining rounds\n    - If remaining rounds <= 5, accepts to avoid negotiation failure\n    - Otherwise accepts if opponent's offer exceeds target utility\n\n**Opponent Modeling:**\n    Uses a library of multiple PlayerData models with different\n    learning rates (delta = 1.0, 1.05, 0.55):\n\n    - Each model tracks value frequencies with exponential weighting\n    - Issue weights derived from maximum value frequencies\n    - Randomly selects which model to use for each decision\n    - Tracks Nash-optimal opponent (whose bids maximize product of\n      estimated utilities) for weighting decisions\n\n    Three weighting strategies randomly selected:\n    1. Nash-based: weight by Nash optimality history\n    2. Equal: all opponents weighted equally\n    3. Alternating: alternate between opponents\n\nReferences:\n    Kakimoto, S., & Fujita, K. (2017). RandomDance: Compromising Strategy\n    Considering Interdependencies of Issues with Randomness. In Fujita, K.,\n    et al. Modern Approaches to Agent-based Complex Automated Negotiation.\n    Studies in Computational Intelligence, vol 674. Springer, Cham.", params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'RandomNegotiator#c475d38c': NegotiatorInfo(key='RandomNegotiator#c475d38c', short_name='RandomNegotiator', full_type_name='negmas.gb.negotiators.randneg.RandomNegotiator', cls=<class 'negmas.gb.negotiators.randneg.RandomNegotiator'>, source='negmas', description='A negotiation agent that responds randomly in a single negotiation.\n\nArgs:\n    p_acceptance: Probability of accepting an offer\n    p_rejection:  Probability of rejecting an offer\n    p_ending: Probability of ending the negotiation at any round\n    can_propose: Whether the agent can propose or not\n    **kwargs: Passed to the GBNegotiator\n\nRemarks:\n\n    - If p_acceptance + p_rejection + p_ending < 1, the rest is the probability of no-response.', params={}, tags={'builtin', 'respond', 'random', 'sao', 'propose'}, extra={}), 'RandomParty#c9c8ce2c': NegotiatorInfo(key='RandomParty#c9c8ce2c', short_name='RandomParty', full_type_name='negmas.genius.gnegotiators.basic.RandomParty', cls=<class 'negmas.genius.gnegotiators.basic.RandomParty'>, source='negmas', description='Random negotiation agent.\n\nMakes completely random offers and acceptance decisions. Useful as a\nbaseline agent for evaluating negotiation strategies.\n\nNote:\n    AI-generated summary. May not be fully accurate.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'RandomParty2#8b8f9899': NegotiatorInfo(key='RandomParty2#8b8f9899', short_name='RandomParty2', full_type_name='negmas.genius.gnegotiators.basic.RandomParty2', cls=<class 'negmas.genius.gnegotiators.basic.RandomParty2'>, source='negmas', description='Random negotiation agent (variant 2).\n\nAlternative implementation of a random negotiation agent. Makes random\noffers from the outcome space with slightly different behavior than\nRandomParty.\n\nNote:\n    AI-generated summary. May not be fully accurate.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'RangeMetaNegotiator#748ee5f1': NegotiatorInfo(key='RangeMetaNegotiator#748ee5f1', short_name='RangeMetaNegotiator', full_type_name='negmas.sao.negotiators.meta.RangeMetaNegotiator', cls=<class 'negmas.sao.negotiators.meta.RangeMetaNegotiator'>, source='negmas', description='An SAO meta-negotiator that samples outcomes within the utility range of sub-negotiator proposals.\n\nThis negotiator collects proposals from all sub-negotiators, computes their utilities,\nand samples an outcome from the outcome space that falls within the min/max utility range\ndefined by those proposals.\n\nFor response aggregation, it uses majority voting among sub-negotiators.\n\nArgs:\n    negotiators: An iterable of `SAONegotiator` instances to manage. Mutually exclusive with `negotiator_types`.\n    negotiator_types: An iterable of `SAONegotiator` types to instantiate. Mutually exclusive with `negotiators`.\n    negotiator_params: Optional iterable of parameter dicts for each negotiator type. Only used with `negotiator_types`.\n    negotiator_names: Optional names for the negotiators.\n    max_cardinality: Maximum number of outcomes to sample when searching for outcomes\n        in the utility range. Defaults to 10000.\n    *args: Additional positional arguments passed to the base class.\n    **kwargs: Additional keyword arguments passed to the base class.\n\nExample:\n    >>> from negmas.sao.negotiators import (\n    ...     RangeMetaNegotiator,\n    ...     BoulwareTBNegotiator,\n    ...     ConcederTBNegotiator,\n    ... )\n    >>> from negmas.sao import SAOMechanism\n    >>> from negmas.preferences import LinearAdditiveUtilityFunction as U\n    >>> from negmas.outcomes import make_issue, make_os\n    >>>\n    >>> issues = [make_issue(10, "price")]\n    >>> os = make_os(issues)\n    >>> ufun1 = U.random(os, reserved_value=0.0)\n    >>> ufun2 = U.random(os, reserved_value=0.0)\n    >>>\n    >>> # Create a range meta-negotiator with diverse strategies\n    >>> meta = RangeMetaNegotiator(\n    ...     negotiator_types=[BoulwareTBNegotiator, ConcederTBNegotiator],\n    ...     ufun=ufun1,\n    ... )\n    >>> opponent = ConcederTBNegotiator(ufun=ufun2)\n    >>>\n    >>> mechanism = SAOMechanism(issues=issues, n_steps=50)\n    >>> _ = mechanism.add(meta)\n    >>> _ = mechanism.add(opponent)\n    >>> result = mechanism.run()\n    >>> result.running\n    False', params={}, tags={'ensemble', 'builtin', 'respond', 'sao', 'meta', 'propose'}, extra={}), 'Rubick#248b5999': NegotiatorInfo(key='Rubick#248b5999', short_name='Rubick', full_type_name='negmas.genius.gnegotiators.y2017.Rubick', cls=<class 'negmas.genius.gnegotiators.y2017.Rubick'>, source='negmas', description='Rubick negotiation agent.\n\n**ANAC 2017 Individual Utility Category Finalist**.\n\nRubick Agent by Okan Tunali is a complex time-based conceder enriched\nwith frequency-based opponent modeling. It maintains the highest utility\never received as a lower bound and uses randomized Boulware-style\nconcession with increasing variance over time.\n\n**Offering Strategy:**\n\n    Generates bids above a target utility using opponent model insights:\n\n    - Searches for bids that maximize intersection with opponent\'s\n      most frequently offered values (frequency-based search)\n    - If no suitable bid found via opponent model, falls back to\n      nearest bid to target utility\n    - Near deadline (t > 0.995), offers from a cached list of\n      previously accepted bids\n\n    Target utility follows randomized Boulware with power parameter\n    randomly selected based on max received utility.\n\n**Acceptance Strategy:**\n\n    Time-based with randomness to prevent exploitation:\n\n    target = 1 - t^power * |N(0, 1/3)|\n\n    where power is randomly 2, 3, or 10 based on opponent behavior.\n    The target is bounded by the maximum received utility.\n    Accepts if opponent offer exceeds target or time > 0.999.\n\n**Opponent Modeling:**\n\n    Employs frequency-based opponent modeling:\n\n    - Tracks value frequencies for each issue per opponent\n    - Extracts "bags" of preferred values (above median frequency)\n    - Scores bids by counting intersections with opponent preferences\n    - Maintains separate models for multilateral scenarios\n\n    Also keeps a sorted list of bids that were accepted by opponents\n    in previous negotiations for use near the deadline.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'SACRA#55051f3c': NegotiatorInfo(key='SACRA#55051f3c', short_name='SACRA', full_type_name='negmas.genius.gnegotiators.y2019.SACRA', cls=<class 'negmas.genius.gnegotiators.y2019.SACRA'>, source='negmas', description='SACRA (Simulated Annealing-based Concession Rate controlling Agent).\n\n**ANAC 2019 competitor.**\n\nUses Simulated Annealing for utility space estimation with Spearman\nrank correlation as fitness metric. Concession rate controlled by\nopponent behavior.\n\n**Offering Strategy:**\n\n    - Generates 20000 candidate bids sorted by utility\n    - Concession rate based on: (lastUtil - firstUtil) / maxUtil * 0.7\n    - Target utility: maxUtil - concessionRate\n    - Selects random bid above target utility\n\n**Acceptance Strategy:**\n\n    - Probabilistic: acceptProb = (receivedUtil - target) / (max - target)\n    - Accepts with probability proportional to how much bid exceeds target\n\n**Preference Estimation:**\n\n    Simulated Annealing (10000 iterations):\n    - Energy = negative Spearman correlation score\n    - Temperature decay: alpha^(iteration/total)\n    - Neighbor generation: modify one weight or value\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.', params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'SAGA#c073a6cd': NegotiatorInfo(key='SAGA#c073a6cd', short_name='SAGA', full_type_name='negmas.genius.gnegotiators.y2019.SAGA', cls=<class 'negmas.genius.gnegotiators.y2019.SAGA'>, source='negmas', description='SAGA (Simulated Annealing Genetic Algorithm) negotiation agent.\n\n**ANAC 2019 Individual Utility Category Finalist**.\n\nSAGA Agent by Yuta Hosokawa applies a Genetic Algorithm approach to estimate\nits own preferences (using Spearman correlation as the fitness function)\ncombined with time-based bidding and acceptance strategies.\n\n**Offering Strategy:**\n\n    Uses a time-dependent target utility function:\n\n    target(t) = target_min + (1 - target_min) * (1 - t^5)\n\n    where target_min is derived from the utility of the first received\n    bid: target_min = firstUtil + 0.6 * (1 - firstUtil).\n\n    Bids are randomly generated above the target utility threshold.\n\n**Acceptance Strategy:**\n\n    Employs a three-phase probabilistic acceptance strategy:\n\n    - **Phase 1 (t <= 0.6)**: Probabilistic acceptance based on how much\n      the offer exceeds the target. Uses power function with exponent\n      that increases as time approaches 0.5.\n    - **Phase 2 (0.6 < t < 0.997)**: Gradually increasing acceptance\n      probability for bids below target, with linear interpolation.\n    - **Phase 3 (t >= 0.997)**: Near deadline, accepts with probability\n      proportional to utility squared.\n\n    Always rejects offers below reservation value.\n\n**Opponent Modeling:**\n\n    SAGA Agent was designed to use Genetic Algorithm to estimate\n    preferences, though the current implementation uses actual\n    preferences. The GA approach uses Spearman rank correlation as\n    the fitness metric to evaluate preference estimation quality.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of the Automated\n    Negotiating Agents Competition (ANAC) 2019. In Multi-Agent Systems and\n    Agreement Technologies. EUMAS AT 2020. Lecture Notes in Computer Science,\n    vol 12520. Springer, Cham.', params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'SENGOKU#aa559164': NegotiatorInfo(key='SENGOKU#aa559164', short_name='SENGOKU', full_type_name='negmas.genius.gnegotiators.y2015.SENGOKU', cls=<class 'negmas.genius.gnegotiators.y2015.SENGOKU'>, source='negmas', description='SENGOKU negotiation agent.\n\n**ANAC 2015**.\n\nJapanese-style modular agent with strategy/bidSearch/negotiatingInfo\ncomponents. Features a "last action" phase for final concession attempts.\n\n**Offering Strategy:**\n    - Modular design similar to AgentW/X family\n    - Shift-based bid search for exploring outcome space\n    - Has special "last action" phase near deadline for final\n      concession to avoid negotiation failure\n    - Tracks acceptance rate to adapt strategy\n\n**Acceptance Strategy:**\n    - Time-dependent threshold with acceptance rate tracking\n    - Special handling in "last action" phase\n    - More aggressive acceptance near deadline\n\n**Opponent Modeling:**\n    Tracks negotiation information including acceptance rates\n    to adapt bidding and acceptance strategies dynamically.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'SMACAgent#4d027c45': NegotiatorInfo(key='SMACAgent#4d027c45', short_name='SMACAgent', full_type_name='negmas.genius.gnegotiators.y2018.SMACAgent', cls=<class 'negmas.genius.gnegotiators.y2018.SMACAgent'>, source='negmas', description='SMACAgent (Sophisticated Machine-learning Agent for Negotiations).\n\n**ANAC 2018 competitor.**\n\nPre-optimized parameter arrays (15 configurations) selected by domain\nsize, reservation value, and discount factor. Uses sigmoid utility curves\nand frequency-based opponent modeling.\n\n**Offering Strategy:**\n\n    - Sigmoid utility curves parameterized by pre-optimized config\n    - Parameters selected based on domain characteristics\n\n**Acceptance Strategy:**\n\n    - Uses selected parameter configuration for threshold\n\n**Opponent Modeling:**\n\n    Frequency-based with Chebyshev/Euclidean distance metrics for\n    similarity computation.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'SYAgent#3835775e': NegotiatorInfo(key='SYAgent#3835775e', short_name='SYAgent', full_type_name='negmas.genius.gnegotiators.y2016.SYAgent', cls=<class 'negmas.genius.gnegotiators.y2016.SYAgent'>, source='negmas', description='SYAgent negotiation agent.\n\n**ANAC 2016**.\n\nModular agent with negotiationInfo, bidSearch, and negotiationStrategy\ncomponents. Tracks accepted bids per opponent and uses round counting\n    for time management.\n\n**Offering Strategy:**\n\n    - Uses time-dependent threshold from negotiationStrategy\n    - Generates bids via bidSearch with random seed\n    - Tracks own bid history\n\n**Acceptance Strategy:**\n\n    - Time-dependent threshold-based acceptance\n    - May terminate negotiation based on time conditions\n    - Considers discount factor in utility calculations\n\n**Opponent Modeling:**\n\n    Per-opponent tracking including:\n\n    - Records which bids were accepted by whom (updateAcceptedBid)\n    - Standard negotiationInfo for bid history\n    - Round counter for timing\n    - Separate initialization for new opponents\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Aydogan, R., et al. (2017). The Seventh International Automated Negotiating\n    Agents Competition (ANAC 2016). Studies in Computational Intelligence.\n    Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'Seto#43062d3a': NegotiatorInfo(key='Seto#43062d3a', short_name='Seto', full_type_name='negmas.genius.gnegotiators.y2018.Seto', cls=<class 'negmas.genius.gnegotiators.y2018.Seto'>, source='negmas', description='Seto negotiation agent.\n\n**ANAC 2018 competitor.**\n\nSimilar architecture to Agent33/Shiboy with NegoStats, BidSearch,\nNegoHistory, and NegoStrategy components. Alpha parameter adjusted\nbased on first received bid.\n\n**Offering Strategy:**\n\n    - Uses NegoStrategy with alpha = 4*sqrt(util) + 0.5\n    - Alpha computed from first received bid utility\n\n**Acceptance Strategy:**\n\n    - Time-dependent threshold from NegoStrategy\n\n**Opponent Modeling:**\n\n    Tracks rejected/agreed values via NegoStats component.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'ShahAgent#96166409': NegotiatorInfo(key='ShahAgent#96166409', short_name='ShahAgent', full_type_name='negmas.genius.gnegotiators.y2017.ShahAgent', cls=<class 'negmas.genius.gnegotiators.y2017.ShahAgent'>, source='negmas', description='ShahAgent negotiation agent.\n\n**ANAC 2017**.\n\nShahAgent uses K-means clustering (20 clusters) to analyze opponent bids\nand estimate concession rates. It adapts its bidding based on cluster\nanalysis and negotiation history.\n\n**Offering Strategy:**\n\n    - Time-dependent utility: (pmin + (1-pmin) * (1-f(t))) * discount^t\n    - Clusters opponent bids using K-means (20 clusters)\n    - Tracks cluster history with distribution factor and max distance\n    - History-aware minimum limit adjustment\n\n**Acceptance Strategy:**\n\n    - Accepts bids above dynamic threshold based on cluster analysis\n    - Concession rate estimated from opponent cluster transitions\n\n**Opponent Modeling:**\n\n    - K-means clustering of opponent bid patterns\n    - Tracks cluster distribution and transitions over time\n    - Estimates opponent concession rate from cluster analysis\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'Shiboy#14be6758': NegotiatorInfo(key='Shiboy#14be6758', short_name='Shiboy', full_type_name='negmas.genius.gnegotiators.y2018.Shiboy', cls=<class 'negmas.genius.gnegotiators.y2018.Shiboy'>, source='negmas', description='Shiboy negotiation agent.\n\n**ANAC 2018 competitor.**\n\nModular design identical to Agent33/Seto with NegoStats, BidSearch,\nNegoHistory, and NegoStrategy components.\n\n**Offering Strategy:**\n\n    - BidSearch generates bids above time-dependent threshold\n    - Considers opponent preferences from NegoStats\n\n**Acceptance Strategy:**\n\n    - Time-dependent threshold from NegoStrategy\n\n**Opponent Modeling:**\n\n    Tracks rejected and agreed values per opponent via NegoStats.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'SimilarityAgent#aedf101b': NegotiatorInfo(key='SimilarityAgent#aedf101b', short_name='SimilarityAgent', full_type_name='negmas.genius.gnegotiators.basic.SimilarityAgent', cls=<class 'negmas.genius.gnegotiators.basic.SimilarityAgent'>, source='negmas', description="Similarity-based negotiation agent.\n\nUses bid similarity measures to evaluate and generate offers. Compares\noffers based on how similar they are to previously successful bids or\nto the opponent's apparent preferences.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n\nReferences:\n    Hindriks, K., et al. (2009). The Genius Negotiation Environment.\n    COIN Workshop at AAMAS.", params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'Simpatico#402ef81b': NegotiatorInfo(key='Simpatico#402ef81b', short_name='Simpatico', full_type_name='negmas.genius.gnegotiators.y2014.Simpatico', cls=<class 'negmas.genius.gnegotiators.y2014.Simpatico'>, source='negmas', description="Simpatico negotiation agent.\n\n**ANAC 2014**.\n\nNeighborhood search around opponent bids with cooperation detection.\n\n**Offering Strategy:**\n\n    - Neighborhood search around opponent's previous bids\n    - Random search with vicinity exploration\n    - Adapts search based on opponent cooperation level\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent shows cooperative behavior\n    - Time-dependent threshold with cooperation bonus\n\n**Opponent Modeling:**\n\n    Detects opponent cooperation from bid pattern changes.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.", params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'SimpleAgent#9c25d75f': NegotiatorInfo(key='SimpleAgent#9c25d75f', short_name='SimpleAgent', full_type_name='negmas.genius.gnegotiators.basic.SimpleAgent', cls=<class 'negmas.genius.gnegotiators.basic.SimpleAgent'>, source='negmas', description='Simple baseline negotiation agent.\n\nBasic negotiation agent implementing straightforward negotiation logic.\nMakes offers and accepts based on simple utility thresholds. Useful as\na baseline for testing and comparison.\n\nNote:\n    AI-generated summary. May not be fully accurate.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'SimpleAgent2017#4e3ce266': NegotiatorInfo(key='SimpleAgent2017#4e3ce266', short_name='SimpleAgent2017', full_type_name='negmas.genius.gnegotiators.y2017.SimpleAgent2017', cls=<class 'negmas.genius.gnegotiators.y2017.SimpleAgent2017'>, source='negmas', description='SimpleAgent2017 negotiation agent.\n\n**ANAC 2017**.\n\nSimpleAgent2017 uses a Predictor class for bid generation and has\nhistory-aware threshold adjustment. It delegates most logic to the\nPredictor component.\n\n**Offering Strategy:**\n\n    - Delegates to Predictor class for bid generation\n    - History-aware threshold via setHistoryAndUpdateThreshold()\n\n**Acceptance Strategy:**\n\n    - Threshold-based acceptance adjusted by negotiation history\n    - Simple decision logic delegating to Predictor\n\n**Opponent Modeling:**\n\n    - Handled by Predictor component\n    - Uses history data for prediction\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'SimpleTitForTatNegotiator#8181f1d6': NegotiatorInfo(key='SimpleTitForTatNegotiator#8181f1d6', short_name='SimpleTitForTatNegotiator', full_type_name='negmas.gb.negotiators.titfortat.NaiveTitForTatNegotiator', cls=<class 'negmas.gb.negotiators.titfortat.NaiveTitForTatNegotiator'>, source='negmas', description="Implements a naive tit-for-tat strategy that does not depend on the availability of an opponent model.\n\nArgs:\n    name: Negotiator name\n    preferences: negotiator preferences\n    ufun: negotiator ufun (overrides preferences)\n    parent: A controller\n    kindness: How 'kind' is the agent. A value of zero is standard tit-for-tat. Positive values makes the negotiator\n              concede faster and negative values slower.\n    stochastic: If `True`, the offers will be randomized above the level determined by the current concession\n                    which in turn reflects the opponent's concession.\n    punish: If `True` the agent punish a partner who does not seem to conede by requiring higher utilities\n    initial_concession: How much should the agent concede in the beginning in terms of utility. Should be a number\n                        or the special string value 'min' for minimum concession\n\nRemarks:\n\n    - This negotiator does not keep an opponent model. It thinks only in terms of changes in its own utility.\n      If the opponent's last offer was better for the negotiator compared with the one before it, it considers\n      that the opponent has conceded by the difference. This means that it implicitly assumes a zero-sum\n      situation.", params={}, tags={'tit-for-tat', 'builtin', 'respond', 'sao', 'propose'}, extra={}), 'SlavaAgent#fcc4115b': NegotiatorInfo(key='SlavaAgent#fcc4115b', short_name='SlavaAgent', full_type_name='negmas.genius.gnegotiators.y2013.SlavaAgent', cls=<class 'negmas.genius.gnegotiators.y2013.SlavaAgent'>, source='negmas', description='SlavaAgent negotiation agent.\n\n**ANAC 2013**.\n\nTwo-phase negotiation strategy with exploration and exploitation phases.\nMaintains persistent storage of best offers across sessions.\n\n**Offering Strategy:**\n\n    - Exploration phase (t < 0.95): offers from high-utility bids (> 0.95)\n    - 50% chance to offer maximum utility bid vs random good bid\n    - Exploitation phase (t >= 0.95): more aggressive concession\n    - Stores and reuses best bids across sessions\n\n**Acceptance Strategy:**\n\n    - Accepts if utility > 0.9 (high threshold)\n    - Also accepts if utility > 0.7 AND >= best opponent offer seen\n    - Tracks best opponent offer across sessions\n\n**Learning:**\n\n    - Persists best opponent offers between sessions\n    - Uses session data to inform acceptance decisions\n    - Conservative strategy with high utility requirements\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.', params={}, tags={'genius', 'respond', 'anac-2013', 'propose', 'anac'}, extra={}), 'Sobut#61723178': NegotiatorInfo(key='Sobut#61723178', short_name='Sobut', full_type_name='negmas.genius.gnegotiators.y2014.Sobut', cls=<class 'negmas.genius.gnegotiators.y2014.Sobut'>, source='negmas', description='Sobut negotiation agent.\n\n**ANAC 2014**.\n\nSimple random walker with multi-session learning.\n\n**Offering Strategy:**\n\n    - Random bid selection above minimum utility threshold\n    - Minimum bid utility derived from past session outcomes\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent bid exceeds learned minimum threshold\n    - Threshold based on discounted utility from past agreements\n\n**Multi-Session Learning:**\n\n    Saves discounted utility outcomes to inform future sessions.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'SolverAgent#764ca62e': NegotiatorInfo(key='SolverAgent#764ca62e', short_name='SolverAgent', full_type_name='negmas.genius.gnegotiators.y2019.SolverAgent', cls=<class 'negmas.genius.gnegotiators.y2019.SolverAgent'>, source='negmas', description='SolverAgent negotiation agent.\n\n**ANAC 2019 competitor.**\n\nSophisticated preference estimation using pairwise comparison from\nbid rankings. Uses Copeland-style analysis and OLS regression. Nash\nbargaining solution search near deadline.\n\n**Offering Strategy:**\n\n    - Phase 1 (t < 30%): random bids above threshold (0.55-0.75)\n    - Phase 2 (30-97%): cycles through high-utility bids\n    - Phase 3 (>97%): offers Nash bid or max opponent bid\n\n**Acceptance Strategy:**\n\n    - Accepts if own planned bid utility <= received bid utility\n    - Or if received bid above phase threshold\n\n**Opponent Modeling:**\n\n    OLS regression on opponent bid history to estimate opponent\n    utilities. Nash product maximization for win-win bids.\n\n**Preference Estimation:**\n\n    Complex pairwise analysis of bid rankings with issue and\n    value ordering inference.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.', params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'Sontag#5e862262': NegotiatorInfo(key='Sontag#5e862262', short_name='Sontag', full_type_name='negmas.genius.gnegotiators.y2018.Sontag', cls=<class 'negmas.genius.gnegotiators.y2018.Sontag'>, source='negmas', description='Sontag negotiation agent.\n\n**ANAC 2018 competitor.**\n\nSimple time-based agent with persistent history. Uses logarithmic\nlower bound formula for concession.\n\n**Offering Strategy:**\n\n    - Lower bound: t/2.5 - log10(t/2 + 0.1)\n    - Generates random bids within utility bounds\n\n**Acceptance Strategy:**\n\n    - Accepts if utility exceeds lower bound\n\n**Opponent Modeling:**\n\n    Uses persistent history from previous sessions but no explicit\n    opponent model.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.', params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'SouthamptonAgent#8b5d3601': NegotiatorInfo(key='SouthamptonAgent#8b5d3601', short_name='SouthamptonAgent', full_type_name='negmas.genius.gnegotiators.y2010.SouthamptonAgent', cls=<class 'negmas.genius.gnegotiators.y2010.SouthamptonAgent'>, source='negmas', description='SouthamptonAgent negotiation agent.\n\n**ANAC 2010 Finalist** (University of Southampton).\n\nSouthamptonAgent is an abstract base class for Southampton agents that provides\ncommon infrastructure for opponent modeling and bid space analysis.\n\n**Offering Strategy:**\n\n    - Abstract methods for initial and subsequent bids (implemented by subclasses)\n    - Tracks own bidding history\n    - Maintains bid space representation for analysis\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent\'s bid × 1.02 ≥ own last bid\'s utility\n    - Accepts if opponent\'s bid × 1.02 ≥ maximum aspiration (0.9)\n    - Accepts if opponent\'s bid × 1.02 ≥ planned next bid\'s utility\n    - Detects if opponent is a "hardhead" (no significant concession)\n\n**Opponent Modeling:**\n\n    General framework:\n\n    - Maintains opponent model infrastructure\n    - Tracks all opponent bids for analysis\n    - Provides utilities for bid space analysis\n    - Subclasses implement specific modeling strategies\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Williams, C.R., Robu, V., Gerding, E.H., & Jennings, N.R. (2011).\n    An Overview of the Results and Insights from the First Automated\n    Negotiating Agents Competition (ANAC 2010). In New Trends in Agent-Based\n    Complex Automated Negotiations. Studies in Computational Intelligence,\n    vol 383. Springer.', params={}, tags={'genius', 'anac-2010', 'respond', 'propose', 'anac'}, extra={}), 'TMFAgent#074ea103': NegotiatorInfo(key='TMFAgent#074ea103', short_name='TMFAgent', full_type_name='negmas.genius.gnegotiators.y2013.TMFAgent', cls=<class 'negmas.genius.gnegotiators.y2013.TMFAgent'>, source='negmas', description='TMFAgent negotiation agent.\n\n**ANAC 2013**.\n\nTime-aware agent with Round Trip Time (RTT) estimation for timeout\nprevention. Builds opponent utility model and optimizes for joint gains.\n\n**Offering Strategy:**\n\n    - Sorts all possible bids by own utility\n    - Searches for bids with best combined utility (own + estimated opponent)\n    - Uses "hardness" parameter based on time and discount factor\n    - Becomes more concessive as deadline approaches\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent bid utility exceeds computed threshold\n    - Threshold decreases over time based on hardness parameter\n    - Considers discount factor in threshold computation\n\n**Opponent Modeling:**\n\n    - Time-weighted frequency model for opponent preferences\n    - Estimates opponent utility for each possible bid\n    - Updates model incrementally with each opponent bid\n\n**Time Management:**\n\n    - Estimates RTT to prevent timeout near deadline\n    - Adjusts offer generation speed based on remaining time\n    - Conservative time handling for reliability\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.', params={}, tags={'genius', 'respond', 'anac-2013', 'propose', 'anac'}, extra={}), 'TUDMixedStrategyAgent#011dae82': NegotiatorInfo(key='TUDMixedStrategyAgent#011dae82', short_name='TUDMixedStrategyAgent', full_type_name='negmas.genius.gnegotiators.y2015.TUDMixedStrategyAgent', cls=<class 'negmas.genius.gnegotiators.y2015.TUDMixedStrategyAgent'>, source='negmas', description="TUDMixedStrategyAgent negotiation agent.\n\n**ANAC 2015**.\n\nFrom TU Delft. Uses mixed strategy with opponent utility function\nmodeling. May re-offer previously received bids strategically.\n\n**Offering Strategy:**\n    - Mixed strategy combining multiple approaches\n    - Uses AgentUtils class for opponent utility estimation\n    - May re-offer bids previously received from opponents\n    - Strategy class determines next bid utility target\n\n**Acceptance Strategy:**\n    - Strategy class determines acceptance conditions\n    - Considers estimated opponent utility in decisions\n    - Adaptive threshold based on negotiation progress\n\n**Opponent Modeling:**\n    AgentUtils-based utility function modeling:\n\n    - Estimates opponent's utility function from bid history\n    - Uses model to evaluate bid quality for opponent\n    - Informs both offering and acceptance decisions\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.", params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'TUDelftGroup2#1899e135': NegotiatorInfo(key='TUDelftGroup2#1899e135', short_name='TUDelftGroup2', full_type_name='negmas.genius.gnegotiators.y2014.TUDelftGroup2', cls=<class 'negmas.genius.gnegotiators.y2014.TUDelftGroup2'>, source='negmas', description='TUDelftGroup2 negotiation agent.\n\n**ANAC 2014**.\n\nBOA framework agent with custom opponent model and bidding strategy.\n\n**Offering Strategy:**\n\n    - Group2_BS custom bidding strategy\n    - Decoupled component-based approach\n\n**Acceptance Strategy:**\n\n    - Group2_AS custom acceptance strategy\n\n**Opponent Modeling:**\n\n    Group2_OM - Custom opponent model for preference estimation.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'TaxiBox#7efcfc72': NegotiatorInfo(key='TaxiBox#7efcfc72', short_name='TaxiBox', full_type_name='negmas.genius.gnegotiators.y2017.TaxiBox', cls=<class 'negmas.genius.gnegotiators.y2017.TaxiBox'>, source='negmas', description='TaxiBox negotiation agent.\n\n**ANAC 2017**.\n\nTaxiBox uses adaptive target utility with emax estimation based on\nopponent behavior tracking. It adjusts its target dynamically based on\nthe difference between expected and actual opponent utilities.\n\n**Offering Strategy:**\n\n    - Estimates emax: avg + (1-avg) * |diff|\n    - Target formula: 1 - (1-emax) * (0.8t)^(3 + 2*shiwang - 0.8t)\n    - Tracks opponent utility average and changes\n    - Adaptive concession based on opponent responsiveness\n\n**Acceptance Strategy:**\n\n    - Accepts bids above current target utility\n    - Target adapts based on opponent utility patterns\n\n**Opponent Modeling:**\n\n    - Tracks average utility of opponent offers\n    - Monitors utility changes to estimate opponent concession\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'Terra#b1777763': NegotiatorInfo(key='Terra#b1777763', short_name='Terra', full_type_name='negmas.genius.gnegotiators.y2016.Terra', cls=<class 'negmas.genius.gnegotiators.y2016.Terra'>, source='negmas', description='Terra negotiation agent.\n\n**ANAC 2016**.\n\nTerra uses a modular architecture with separate components for information\ntracking, bid search, and negotiation strategy. It maintains per-opponent\nlists of agreed and disagreed values to inform its bidding decisions.\n\n**Offering Strategy:**\n\n    - Uses `bidSearch.getBid()` with a random seed and time-dependent threshold\n    - Threshold obtained via `negotiationStrategy.getThreshold(time)`\n    - Can end negotiation early via `selectEndNegotiation(time)` check\n\n**Acceptance Strategy:**\n\n    - Accepts offers above the current threshold from negotiationStrategy\n    - May terminate negotiation early based on strategic assessment\n\n**Opponent Modeling:**\n\n    - Tracks agreed values list per opponent (values they accepted)\n    - Tracks disagreed values list per opponent (values they rejected)\n    - Tracks all offered bids per opponent\n    - Updates opponent information on each received message\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Fujita, K., et al. (2016). ANAC 2016 Individual Utility category analysis.\n    In Proceedings of IJCAI Workshop on Autonomous Agents.', params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'TheFawkes#23942576': NegotiatorInfo(key='TheFawkes#23942576', short_name='TheFawkes', full_type_name='negmas.genius.gnegotiators.y2013.TheFawkes', cls=<class 'negmas.genius.gnegotiators.y2013.TheFawkes'>, source='negmas', description='TheFawkes negotiation agent.\n\n**ANAC 2013**.\n\nBOA framework-based agent with custom components for opponent modeling,\noffer generation, and acceptance. Named after Guy Fawkes.\n\n**Offering Strategy:**\n\n    - Fawkes_Offering bidding strategy component\n    - Uses opponent model to find mutually beneficial bids\n    - Time-dependent concession behavior\n\n**Acceptance Strategy:**\n\n    - AC_TheFawkes acceptance component\n    - Considers predicted opponent utility in decisions\n    - Balances own utility with negotiation progress\n\n**Opponent Modeling:**\n\n    - TheFawkes_OM opponent model component\n    - TheFawkes_OMS opponent model strategy\n    - Learns opponent preferences from bid history\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.', params={}, tags={'genius', 'respond', 'anac-2013', 'propose', 'anac'}, extra={}), 'TheNegotiator#cb5af861': NegotiatorInfo(key='TheNegotiator#cb5af861', short_name='TheNegotiator', full_type_name='negmas.genius.gnegotiators.y2011.TheNegotiator', cls=<class 'negmas.genius.gnegotiators.y2011.TheNegotiator'>, source='negmas', description='TheNegotiator agent.\n\n**ANAC 2011**.\n\nA phase-based negotiation agent that divides the negotiation into\ndistinct phases with different strategies. Uses time management and\na bid generator to create offers.\n\n**Offering Strategy:**\n\n    - Maintains a collection of all possible bids sorted by utility\n    - Generates offers based on current phase and threshold\n    - BidGenerator selects appropriate bids meeting phase requirements\n    - Threshold varies by phase and time remaining\n\n**Acceptance Strategy:**\n\n    - Phase-dependent acceptance thresholds\n    - Phase 3 (endgame): considers moves left before deadline\n    - Acceptor component evaluates opponent bids against threshold\n    - More lenient acceptance as deadline approaches\n\n**Time Management:**\n\n    - Divides negotiation into 3 phases\n    - Tracks elapsed time and estimates moves remaining\n    - Adjusts threshold based on discount factor\n    - Phase transitions trigger strategy changes\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Dirkzwager, A., Hendrikx, M., & de Ruiter, J. (2013). TheNegotiator:\n    A dynamic strategy for bilateral automated negotiation. In Complex\n    Automated Negotiations: Theories, Models, and Software Competitions.\n    Studies in Computational Intelligence, vol 435. Springer.', params={}, tags={'genius', 'respond', 'anac', 'propose', 'anac-2011'}, extra={}), 'TheNegotiatorReloaded#4607b7cd': NegotiatorInfo(key='TheNegotiatorReloaded#4607b7cd', short_name='TheNegotiatorReloaded', full_type_name='negmas.genius.gnegotiators.y2012.TheNegotiatorReloaded', cls=<class 'negmas.genius.gnegotiators.y2012.TheNegotiatorReloaded'>, source='negmas', description='TheNegotiatorReloaded negotiation agent.\n\n**ANAC 2012**.\n\nAn enhanced BOA-framework version of TheNegotiator using modular\ncomponents for opponent modeling, offering strategy, and acceptance.\n\n**Architecture (BOA Framework):**\n\n    - Opponent Model: IAMhagglerBayesianModel (if domain < 200K bids)\n      or NoModel for large domains\n    - OM Strategy: NullStrategy with threshold 0.35\n    - Offering: TheNegotiatorReloaded_Offering strategy\n    - Acceptance: Custom conditions with multiple parameters\n\n**Acceptance Strategy:**\n\n    Parameterized acceptance with:\n\n    - Alpha=1, Beta=0: basic threshold multipliers\n    - Gamma=1.05: acceptance utility multiplier\n    - Delta=0: time-based adjustment\n    - Threshold bounds: [0.98, 0.99]\n\n**Opponent Modeling:**\n\n    - Bayesian model (IAMhaggler variant) for small domains\n    - Disabled for large domains (> 200K possible bids)\n    - Used to estimate opponent preferences\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.', params={}, tags={'genius', 'respond', 'anac-2012', 'propose', 'anac'}, extra={}), 'TheNewDeal#4eda5fa5': NegotiatorInfo(key='TheNewDeal#4eda5fa5', short_name='TheNewDeal', full_type_name='negmas.genius.gnegotiators.y2019.TheNewDeal', cls=<class 'negmas.genius.gnegotiators.y2019.TheNewDeal'>, source='negmas', description='TheNewDeal negotiation agent.\n\n**ANAC 2019 competitor.**\n\nEstimates utilities using equal-difference distribution from bid\nranking. Calculates value weights using linear equation solving\nand issue weights from consecutive value matches.\n\n**Offering Strategy:**\n\n    - Offers bids in decreasing utility order\n    - Ratio-based timing: offers at intervals proportional to\n      domain size / timeline\n    - Cycles back to start after reaching midpoint\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent bid utility >= own next bid utility\n    - Final round: always accepts (if not first agent)\n\n**Preference Estimation:**\n\n    - Equal-difference utility distribution across bid ranking\n    - Value weights via linear equation solving per value\n    - Issue weights from consecutive match frequency\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.', params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'TimeBasedConcedingNegotiator#d846b177': NegotiatorInfo(key='TimeBasedConcedingNegotiator#d846b177', short_name='TimeBasedConcedingNegotiator', full_type_name='negmas.gb.negotiators.timebased.TimeBasedConcedingNegotiator', cls=<class 'negmas.gb.negotiators.timebased.TimeBasedConcedingNegotiator'>, source='negmas', description='Represents a time-based negotiation strategy that is independent of the offers received during the negotiation.\n\nArgs:\n    offering_curve (TimeCurve): A `TimeCurve` that is to be used to sample outcomes when offering\n    accepting_curve (TimeCurve): A `TimeCurve` that is to be used to decide utility range to accept\n    starting_utility (float): The relative utility (range 1.0 to 0.0) at which to give the first offer. Only used if `offering_curve` was not given', params={}, tags={'builtin', 'respond', 'sao', 'propose', 'time-based'}, extra={}), 'TimeBasedNegotiator#bdd96184': NegotiatorInfo(key='TimeBasedNegotiator#bdd96184', short_name='TimeBasedNegotiator', full_type_name='negmas.gb.negotiators.timebased.TimeBasedNegotiator', cls=<class 'negmas.gb.negotiators.timebased.TimeBasedNegotiator'>, source='negmas', description='Represents a time-based negotiation strategy that is independent of the offers received during the negotiation.\n\nArgs:\n    offering_curve (TimeCurve): A `TimeCurve` that is to be used to sample outcomes when offering\n    accepting_curve (TimeCurve): A `TimeCurve` that is to be used to decide utility range to accept\n    inverter (UtilityInverter): A component used to keep track of the ufun inverse\n    offer_selector (OfferSelector): The way to select an offer from the set of valid offers at every time-step', params={}, tags={'builtin', 'respond', 'sao', 'propose', 'time-based'}, extra={}), 'TimeDependentAgentBoulware#f9ce6645': NegotiatorInfo(key='TimeDependentAgentBoulware#f9ce6645', short_name='TimeDependentAgentBoulware', full_type_name='negmas.genius.gnegotiators.basic.TimeDependentAgentBoulware', cls=<class 'negmas.genius.gnegotiators.basic.TimeDependentAgentBoulware'>, source='negmas', description='Boulware time-dependent negotiation agent.\n\nTime-dependent agent with Boulware (hardheaded) concession. Uses exponent\ne < 1, conceding slowly initially and rapidly near deadline. Maintains\nhigh demands throughout most of the negotiation.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n\nReferences:\n    Faratin, P., Sierra, C., & Jennings, N. R. (1998). Negotiation Decision\n    Functions for Autonomous Agents. Robotics and Autonomous Systems.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'TimeDependentAgentConceder#aa380a6a': NegotiatorInfo(key='TimeDependentAgentConceder#aa380a6a', short_name='TimeDependentAgentConceder', full_type_name='negmas.genius.gnegotiators.basic.TimeDependentAgentConceder', cls=<class 'negmas.genius.gnegotiators.basic.TimeDependentAgentConceder'>, source='negmas', description='Conceder time-dependent negotiation agent.\n\nTime-dependent agent with Conceder strategy. Uses exponent e > 1,\nconceding rapidly at the start and slowly near deadline. Cooperative\napproach that prioritizes reaching agreement.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n\nReferences:\n    Faratin, P., Sierra, C., & Jennings, N. R. (1998). Negotiation Decision\n    Functions for Autonomous Agents. Robotics and Autonomous Systems.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'TimeDependentAgentHardliner#eb60de54': NegotiatorInfo(key='TimeDependentAgentHardliner#eb60de54', short_name='TimeDependentAgentHardliner', full_type_name='negmas.genius.gnegotiators.basic.TimeDependentAgentHardliner', cls=<class 'negmas.genius.gnegotiators.basic.TimeDependentAgentHardliner'>, source='negmas', description='Hardliner time-dependent negotiation agent.\n\nExtreme time-dependent agent that makes minimal or no concessions.\nMaintains maximum utility demands throughout negotiation, only accepting\noffers very close to its ideal outcome.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n\nReferences:\n    Faratin, P., Sierra, C., & Jennings, N. R. (1998). Negotiation Decision\n    Functions for Autonomous Agents. Robotics and Autonomous Systems.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'TimeDependentAgentLinear#d85885d2': NegotiatorInfo(key='TimeDependentAgentLinear#d85885d2', short_name='TimeDependentAgentLinear', full_type_name='negmas.genius.gnegotiators.basic.TimeDependentAgentLinear', cls=<class 'negmas.genius.gnegotiators.basic.TimeDependentAgentLinear'>, source='negmas', description='Linear time-dependent negotiation agent.\n\nTime-dependent agent with linear concession (e = 1). Concedes at a\nconstant rate throughout the negotiation, from maximum utility at\nstart to reservation value at deadline.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n\nReferences:\n    Faratin, P., Sierra, C., & Jennings, N. R. (1998). Negotiation Decision\n    Functions for Autonomous Agents. Robotics and Autonomous Systems.', params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'ToughNegotiator#8756d03c': NegotiatorInfo(key='ToughNegotiator#8756d03c', short_name='ToughNegotiator', full_type_name='negmas.gb.negotiators.tough.ToughNegotiator', cls=<class 'negmas.gb.negotiators.tough.ToughNegotiator'>, source='negmas', description='Accepts and proposes only the top offer (i.e. the one with highest utility).\n\nArgs:\n     name: Negotiator name\n     parent: Parent controller if any\n     can_propose: If `False` the negotiator will never propose but can only accept\n     preferences: The preferences of the negotiator\n     ufun: The ufun of the negotiator (overrides preferences)\n     owner: The `Agent` that owns the negotiator.\n\nRemarks:\n    - If there are multiple outcome with the same maximum utility, only one of them will be used.', params={}, tags={'builtin', 'respond', 'sao', 'propose', 'aspiration'}, extra={}), 'TucAgent#6d85eb00': NegotiatorInfo(key='TucAgent#6d85eb00', short_name='TucAgent', full_type_name='negmas.genius.gnegotiators.y2017.TucAgent', cls=<class 'negmas.genius.gnegotiators.y2017.TucAgent'>, source='negmas', description='TucAgent negotiation agent.\n\n**ANAC 2017**.\n\nTucAgent uses Bayesian opponent modeling with separate models for each\nopponent in multilateral settings. It employs an IssueManager for\nthreshold calculation and bid generation.\n\n**Offering Strategy:**\n\n    - IssueManager handles bid generation and threshold calculation\n    - Uses Bayesian models to predict opponent preferences\n    - Selects bids based on combined opponent model predictions\n\n**Acceptance Strategy:**\n\n    - Immediately accepts bids with utility > 0.95\n    - Otherwise uses dynamic threshold from IssueManager\n    - Bayesian models inform acceptance decisions\n\n**Opponent Modeling:**\n\n    - Bayesian opponent model with separate models per opponent\n    - Updates beliefs based on observed opponent offers\n    - IssueManager integrates opponent models for decisions\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code for\n    authoritative information.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'anac-2017', 'respond', 'propose', 'anac'}, extra={}), 'UtilBasedNegotiator#f75f0b8f': NegotiatorInfo(key='UtilBasedNegotiator#f75f0b8f', short_name='UtilBasedNegotiator', full_type_name='negmas.gb.negotiators.utilbased.UtilBasedNegotiator', cls=<class 'negmas.gb.negotiators.utilbased.UtilBasedNegotiator'>, source='negmas', description='A negotiator that bases its decisions on the utility value of outcomes only.\n\nArgs:\n    inverter (UtilityInverter): A component used to keep track of the ufun inverse\n    stochastic (bool): If `False` the worst outcome in the current utility range will be used\n    rank_only (bool): If `True` then the ranks of outcomes not their actual utilities will be used for decision making\n    max_cardinality (int): The number of outocmes at which we switch to use the slower `SamplingInverseUtilityFunction`\n                           instead of the `PresortingInverseUtilityFunction` . Will only be used if `ufun_inverter` is `None`\n    eps (float): A tolearnace around the utility range used when sampling outocmes', params={}, tags={'builtin', 'respond', 'sao', 'utility-based', 'propose'}, extra={}), 'UtilityBasedAcceptor#bbb1beed': NegotiatorInfo(key='UtilityBasedAcceptor#bbb1beed', short_name='UtilityBasedAcceptor', full_type_name='negmas.genius.gnegotiators.basic.UtilityBasedAcceptor', cls=<class 'negmas.genius.gnegotiators.basic.UtilityBasedAcceptor'>, source='negmas', description="Utility-based acceptance strategy agent.\n\nAccepts offers based purely on utility threshold comparison. If an\noffer's utility exceeds the current threshold (which may vary over\ntime), it accepts; otherwise rejects.\n\nNote:\n    AI-generated summary. May not be fully accurate.\n\nReferences:\n    Baarslag, T., et al. (2014). Decoupling Negotiating Agents to Explore\n    the Space of Negotiation Strategies. AAMAS.", params={}, tags={'genius', 'respond', 'basic', 'propose'}, extra={}), 'ValueModelAgent#4cc440c1': NegotiatorInfo(key='ValueModelAgent#4cc440c1', short_name='ValueModelAgent', full_type_name='negmas.genius.gnegotiators.y2011.ValueModelAgent', cls=<class 'negmas.genius.gnegotiators.y2011.ValueModelAgent'>, source='negmas', description='ValueModelAgent negotiation agent.\n\n**ANAC 2011**.\n\nUses temporal difference reinforcement learning to model opponent\'s\nutility space by learning utility loss per issue value. Slows\nconcession rate until fairness requires compromise.\n\n**Offering Strategy:**\n\n    - Maintains approved bids above current threshold (starts at 0.98)\n    - Sorts approved bids by estimated opponent utility\n    - Alternates between "best" scan (highest opponent utility) and\n      "explore" scan (trying new value combinations)\n    - Endgame "chicken game": waits, then offers opponent\'s best bid\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent utility > threshold and discounted, or > 0.975\n    - Time-phased acceptance in final 10%:\n      - 90-96%: accepts at lowered threshold\n      - 96-99%: progressively more accepting\n      - 99%+: accepts opponent\'s best if utility > 0.55\n    - Adjusts threshold based on opponent concession\n\n**Opponent Modeling:**\n\n    Temporal Difference learning approach:\n\n    - Models utility loss per value in each issue\n    - Uses reliability and standard deviation to split learning updates\n    - Tracks opponent bid history and concession patterns\n    - ValueSeperatedBids structure organizes bids by issue values\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.', params={}, tags={'genius', 'respond', 'anac', 'propose', 'anac-2011'}, extra={}), 'WABNegotiator#67a72dd5': NegotiatorInfo(key='WABNegotiator#67a72dd5', short_name='WABNegotiator', full_type_name='negmas.gb.negotiators.war.WABNegotiator', cls=<class 'negmas.gb.negotiators.war.WABNegotiator'>, source='negmas', description='Wasting Accepting Better (neither complete nor an equilibrium)\n\nArgs:\n     name: Negotiator name\n     parent: Parent controller if any\n     preferences: The preferences of the negotiator\n     ufun: The ufun of the negotiator (overrides preferences)\n     owner: The `Agent` that owns the negotiator.', params={}, tags={'builtin', 'respond', 'wab-family', 'sao', 'learning', 'propose'}, extra={}), 'WANNegotiator#c4d4187a': NegotiatorInfo(key='WANNegotiator#c4d4187a', short_name='WANNegotiator', full_type_name='negmas.gb.negotiators.war.WANNegotiator', cls=<class 'negmas.gb.negotiators.war.WANNegotiator'>, source='negmas', description='Wasting Accepting Any (an equilibrium but not complete)\n\nArgs:\n     name: Negotiator name\n     parent: Parent controller if any\n     preferences: The preferences of the negotiator\n     ufun: The ufun of the negotiator (overrides preferences)\n     owner: The `Agent` that owns the negotiator.', params={}, tags={'builtin', 'respond', 'wab-family', 'sao', 'learning', 'propose'}, extra={}), 'WARNegotiator#f2c0cb4f': NegotiatorInfo(key='WARNegotiator#f2c0cb4f', short_name='WARNegotiator', full_type_name='negmas.gb.negotiators.war.WARNegotiator', cls=<class 'negmas.gb.negotiators.war.WARNegotiator'>, source='negmas', description='Wasting Accepting Any (an equilibrium but not complete)\n\nArgs:\n     name: Negotiator name\n     parent: Parent controller if any\n     preferences: The preferences of the negotiator\n     ufun: The ufun of the negotiator (overrides preferences)\n     owner: The `Agent` that owns the negotiator.', params={}, tags={'builtin', 'respond', 'wab-family', 'sao', 'learning', 'propose'}, extra={}), 'WhaleAgent#f8b8589c': NegotiatorInfo(key='WhaleAgent#f8b8589c', short_name='WhaleAgent', full_type_name='negmas.genius.gnegotiators.y2014.WhaleAgent', cls=<class 'negmas.genius.gnegotiators.y2014.WhaleAgent'>, source='negmas', description='WhaleAgent negotiation agent.\n\n**ANAC 2014**.\n\nMulti-session learning with action type switching.\n\n**Offering Strategy:**\n\n    - Action type switching: aggressive vs passive modes\n    - Simulated annealing and neighbor search for bid generation\n    - Sigmoid-based threshold functions\n\n**Acceptance Strategy:**\n\n    - Mode-dependent acceptance thresholds\n    - Adapts based on session history and opponent behavior\n\n**Multi-Session Learning:**\n\n    Learns optimal action type (aggressive/passive) across sessions.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n\n    Baarslag, T., et al. (2015). The Automated Negotiating Agents Competition,\n    2010-2015. AI Magazine.', params={}, tags={'genius', 'anac-2014', 'respond', 'propose', 'anac'}, extra={}), 'WinkyAgent#94730e78': NegotiatorInfo(key='WinkyAgent#94730e78', short_name='WinkyAgent', full_type_name='negmas.genius.gnegotiators.y2019.WinkyAgent', cls=<class 'negmas.genius.gnegotiators.y2019.WinkyAgent'>, source='negmas', description='WinkyAgent negotiation agent.\n\n**ANAC 2019 competitor.**\n\nUses Batch Gradient Descent (BGD) for utility estimation from bid\nrankings. One-hot encodes bids and trains value parameters. Time-phased\nstrategy with opponent bid tracking.\n\n**Offering Strategy:**\n\n    - t < 70%: random bids above threshold (0.7-0.82 based on max)\n    - t < 98%: similar with slightly lower threshold\n    - t < 99%: offers from sorted received bids (top 3%)\n    - Final: accepts or offers best received bid\n\n**Acceptance Strategy:**\n\n    - Time-dependent thresholds relative to highest received utility\n    - t < 99%: accepts if utility > highestReceived - 0.03\n    - Later: progressively relaxes threshold\n\n**Preference Estimation:**\n\n    BGD training:\n    - One-hot encoded bid features\n    - Learning rate = initial value utility / 10\n    - Iterations = ranklistSize * valueSum\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Aydogan, R. et al. (2020). Challenges and Main Results of ANAC 2019.', params={}, tags={'genius', 'anac-2019', 'respond', 'propose', 'anac'}, extra={}), 'XianFaAgent#e72859a1': NegotiatorInfo(key='XianFaAgent#e72859a1', short_name='XianFaAgent', full_type_name='negmas.genius.gnegotiators.y2015.XianFaAgent', cls=<class 'negmas.genius.gnegotiators.y2015.XianFaAgent'>, source='negmas', description='XianFaAgent negotiation agent.\n\n**ANAC 2015**.\n\nUses tree-based statistical opponent modeling with custom Tree, Node,\nand Statistician classes in the xianfa package.\n\n**Offering Strategy:**\n    - Tree-based bid organization for efficient search\n    - Uses Statistician class to analyze opponent patterns\n    - Adapts bids based on statistical analysis of opponent behavior\n\n**Acceptance Strategy:**\n    - Statistical threshold based on opponent modeling\n    - Uses tree structure to evaluate bid quality\n\n**Opponent Modeling:**\n    Tree-based statistician model (xianfa package):\n\n    - Tree and Node classes for hierarchical bid organization\n    - Statistician class for opponent behavior analysis\n    - Statistical inference on opponent preferences\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'Y2015Group2#90a8a5a6': NegotiatorInfo(key='Y2015Group2#90a8a5a6', short_name='Y2015Group2', full_type_name='negmas.genius.gnegotiators.y2015.Y2015Group2', cls=<class 'negmas.genius.gnegotiators.y2015.Y2015Group2'>, source='negmas', description='Y2015Group2 negotiation agent.\n\n**ANAC 2015**.\n\nAlias for Group2. Uses Pareto-optimal bid search with per-party\nopponent modeling. See Group2 for full documentation.\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Refer to the original source code and papers\n    for authoritative information.\n\nReferences:\n    Fujita, K., et al. (2017). The Sixth Automated Negotiating Agents Competition\n    (ANAC 2015). Studies in Computational Intelligence, vol 674. Springer, Cham.', params={}, tags={'genius', 'respond', 'anac-2015', 'propose', 'anac'}, extra={}), 'YXAgent#6cf072e5': NegotiatorInfo(key='YXAgent#6cf072e5', short_name='YXAgent', full_type_name='negmas.genius.gnegotiators.y2016.YXAgent', cls=<class 'negmas.genius.gnegotiators.y2016.YXAgent'>, source='negmas', description='YXAgent negotiation agent.\n\n**ANAC 2016 Individual Utility Category Runner-up**.\n\nYXAgent employs a frequency-based opponent modeling approach combined with\nthreshold-based bidding and acceptance strategies. The agent maintains\nseparate models for issue weights and value frequencies for each opponent,\nidentifying the "toughest" opponent to inform its acceptance decisions.\n\n**Offering Strategy:**\n\n    The agent generates random bids above a threshold that is calculated\n    based on the number of opponents (minimum 0.7). In early rounds, it\n    offers bids with utility above a temporary threshold. After 10 rounds\n    and before 90% of the time has elapsed, it uses the opponent model to\n    calculate a more nuanced threshold based on the estimated utility of\n    the opponent\'s last bid according to the toughest opponent\'s model.\n\n**Acceptance Strategy:**\n\n    - In early rounds (first 10) or late game (>90% time): accepts if the\n      opponent\'s offer utility exceeds the temporary threshold.\n    - During mid-game: accepts if the opponent\'s offer utility exceeds a\n      calculated threshold that accounts for the opponent model\'s\n      evaluation of the bid.\n\n**Opponent Modeling:**\n\n    YXAgent builds frequency-based models for each opponent:\n\n    - **Issue weights**: Updated when the opponent keeps the same value\n      for an issue between consecutive bids, using a time-decaying formula.\n    - **Value frequencies**: Tracks how often each value is offered,\n      normalized by the maximum frequency.\n    - Identifies the "hardest" (toughest) opponent based on their behavior.\n\nReferences:\n\n    Aydogan, R., Fujita, K., Baarslag, T., Jonker, C. M., & Ito, T. (2021).\n    ANAC 2017: Repeated multilateral negotiation league.\n    In Advances in Automated Negotiations (pp. 101-115). Springer Singapore.', params={}, tags={'genius', 'respond', 'anac-2016', 'propose', 'anac'}, extra={}), 'Yeela#b1caaa6d': NegotiatorInfo(key='Yeela#b1caaa6d', short_name='Yeela', full_type_name='negmas.genius.gnegotiators.y2018.Yeela', cls=<class 'negmas.genius.gnegotiators.y2018.Yeela'>, source='negmas', description="Yeela negotiation agent.\n\n**ANAC 2018 competitor.**\n\nUses Learner class with genetic algorithm style optimization. Tracks\nbest received offer and may offer it if better than generated bids.\n\n**Offering Strategy:**\n\n    - Generates bids via Learner optimization\n    - May offer best received bid if it's better than generated\n    - Compares new offers against all previous bids\n\n**Acceptance Strategy:**\n\n    - Gives up negotiation at t=0.75 if no acceptable agreement\n\n**Opponent Modeling:**\n\n    Tracks best received offer from opponents.\n\nNote:\n    AI-generated summary based on Java source. May not be fully accurate.\n    Refer to original implementation for authoritative details.\n\nReferences:\n\n    Baarslag, T., et al. (2019). Proceedings of the ANAC 2018 Multilateral\n    Negotiation League.", params={}, tags={'genius', 'respond', 'anac-2018', 'propose', 'anac'}, extra={}), 'Yushu#f4e086e9': NegotiatorInfo(key='Yushu#f4e086e9', short_name='Yushu', full_type_name='negmas.genius.gnegotiators.y2010.Yushu', cls=<class 'negmas.genius.gnegotiators.y2010.Yushu'>, source='negmas', description="Yushu negotiation agent.\n\n**ANAC 2010 Finalist**.\n\nYushu uses time-aware concession with opponent bid tracking to adaptively\nadjust targets based on remaining negotiation rounds.\n\n**Offering Strategy:**\n\n    - Starts with maximum utility bid\n    - Calculates target utility using time-based concession: target = max - (max - min) × t^eagerness\n    - Dynamically adjusts minimum acceptable utility based on:\n        - Estimated remaining rounds (based on response time tracking)\n        - Average opponent utility (domain competitiveness indicator)\n    - Iterates through bid space to find bids near target utility\n    - Near deadline, may suggest opponent's best historical offer\n\n**Acceptance Strategy:**\n\n    - Accepts if opponent's utility ≥ target utility\n    - Accepts if opponent's utility ≥ acceptable threshold (time-dependent)\n    - More lenient when fewer rounds remain (< 8 rounds: accept good offers)\n    - May accept opponent's best historical bid near deadline\n\n**Opponent Modeling:**\n\n    Best-offer tracking:\n\n    - Maintains sorted list of top 10 opponent bids by utility\n    - Tracks average opponent utility to assess domain competitiveness\n    - Uses opponent's best offers as fallback suggestions near deadline\n    - Adjusts minimum acceptable utility based on opponent behavior\n\nNote:\n    This description is AI-generated based on the original Java implementation\n    and may not be fully accurate. Please refer to the original source code\n    and papers for authoritative information.\n\nReferences:\n\n    Baarslag, T., Hindriks, K., Hendrikx, M., Dirkzwager, A., & Jonker, C.M. (2014).\n    Decoupling Negotiating Agents to Explore the Space of Negotiation Strategies.\n    In Novel Insights in Agent-based Complex Automated Negotiation.\n    Studies in Computational Intelligence, vol 535. Springer.", params={}, tags={'genius', 'anac-2010', 'respond', 'propose', 'anac'}, extra={})}

The global negotiator registry.

negmas.registry.register_all_scenarios(path: str | Path, source: str = 'unknown', tags: set[str] | list[str] | tuple[str, ...] | None = None, recursive: bool = True, read_only: bool = False, registry: ScenarioRegistry | None = None) → list[ScenarioInfo]

Register all loadable scenarios from a directory.

This function recursively searches for valid negotiation scenarios in the given directory and registers them in the scenario registry. It attempts to load each folder as a scenario, and if that fails, searches for YAML files and subfolders that might be scenarios.

The function extracts all available information from each scenario: - n_outcomes: Number of possible outcomes - n_negotiators: Number of negotiators (from utility functions) - normalized: Whether utilities are normalized to [0, 1] - format: The scenario format (xml, json, yaml)

Scenarios are automatically tagged based on their properties: - “bilateral”: 2 negotiators - “multilateral”: 3+ negotiators - Format tag: “xml”, “json”, or “yaml”

Parameters:

• path – The root directory to search for scenarios.

• source – The origin of these registrations (‘negmas’ for built-in, library name for external, or ‘unknown’ if not specified). Applied to all scenarios registered from this directory.

• tags – Optional tags to add to all registered scenarios.

• recursive – If True, recursively search subdirectories.

• read_only – Whether these scenarios should be read-only (cannot be unregistered).

• registry – The registry to use. If None, uses the global scenario_registry.

Returns:

A list of ScenarioInfo objects for successfully registered scenarios.

Raises:

ValueError – If the path does not exist or is not a directory.

Example

# Register all scenarios from a directory from negmas import register_all_scenarios

scenarios = register_all_scenarios(

“/path/to/scenarios”, source=”my-library”, tags={“custom”, “my-project”},

) print(f”Registered {len(scenarios)} scenarios”)

# Register without recursion scenarios = register_all_scenarios(

“/path/to/scenarios”, source=”my-library”, recursive=False,

)

negmas.registry.register_component(cls: type | None = None, *, short_name: str | None = None, source: str = 'unknown', params: dict[str, Any] | None = None, component_type: str = 'generic', tags: set[str] | list[str] | tuple[str, ...] | None = None, **extra)

Decorator to register a component class.

Can be used with or without arguments:

@register_component class MyComponent(Component):

pass

@register_component(component_type=”acceptance”, tags={“builtin”, “rational”}) class MyAcceptancePolicy(AcceptancePolicy):

pass

Parameters:

• cls – The class to register (when used without parentheses).

• short_name – A short name for the component.

• source – The origin of this registration (‘negmas’ for built-in, library name for external, or ‘unknown’ if not specified).

• params – Default constructor parameters for creating instances.

• component_type – The type of component (e.g., ‘acceptance’, ‘offering’, ‘model’).

• tags – Set of tags for categorization (e.g., {“builtin”, “rational”}).

• **extra – Additional properties to store.

Returns:

The decorated class (unchanged).

negmas.registry.register_mechanism(cls: type | None = None, *, short_name: str | None = None, source: str = 'unknown', params: dict[str, Any] | None = None, requires_deadline: bool = True, tags: set[str] | list[str] | tuple[str, ...] | None = None, **extra)

Decorator to register a mechanism class.

Can be used with or without arguments:

@register_mechanism class MyMechanism(Mechanism):

pass

@register_mechanism(short_name=”my_mech”, requires_deadline=False, tags={“sao”}) class MyMechanism(Mechanism):

pass

Parameters:

• cls – The class to register (when used without parentheses).

• short_name – A short name for the mechanism.

• source – The origin of this registration (‘negmas’ for built-in, library name for external, or ‘unknown’ if not specified).

• params – Default constructor parameters for creating instances.

• requires_deadline – Whether the mechanism requires a deadline.

• tags – Set of tags for categorization (e.g., {“sao”, “builtin”}).

• **extra – Additional properties to store.

Returns:

The decorated class (unchanged).

negmas.registry.register_negotiator(cls: type | None = None, *, short_name: str | None = None, source: str = 'unknown', params: dict[str, Any] | None = None, bilateral_only: bool = False, requires_opponent_ufun: bool = False, learns: bool = False, anac_year: int | None = None, supports_uncertainty: bool = False, supports_discounting: bool = False, tags: set[str] | list[str] | tuple[str, ...] | None = None, **extra)

Decorator to register a negotiator class.

Can be used with or without arguments:

@register_negotiator class MyNegotiator(Negotiator):

pass

@register_negotiator(bilateral_only=True, learns=True, tags={“builtin”, “aspiration”}) class MyNegotiator(Negotiator):

pass

Parameters:

• cls – The class to register (when used without parentheses).

• short_name – A short name for the negotiator.

• source – The origin of this registration (‘negmas’ for built-in, library name for external, or ‘unknown’ if not specified).

• params – Default constructor parameters for creating instances.

• bilateral_only – Whether the negotiator only works bilaterally.

• requires_opponent_ufun – Whether the negotiator needs opponent’s utility.

• learns – Whether the negotiator learns from repeated negotiations.

• anac_year – ANAC competition year (for Genius negotiators).

• supports_uncertainty – Whether uncertain preferences are supported.

• supports_discounting – Whether time-discounted utilities are supported.

• tags – Set of tags for categorization (e.g., {“builtin”, “aspiration”}).

• **extra – Additional properties to store.

Returns:

The decorated class (unchanged).

negmas.registry.register_scenario(path: str | Path, name: str | None = None, source: str = 'unknown', tags: set[str] | list[str] | tuple[str, ...] | None = None, normalized: bool | None = None, n_outcomes: int | None = None, n_negotiators: int | None = None, anac: bool | None = None, has_stats: bool = False, has_plot: bool = False, read_only: bool = False, **extra) → ScenarioInfo

Register a scenario in the global scenario registry.

This function registers a negotiation scenario (a file or folder containing domain and utility definitions) so it can be discovered and used by name.

Parameters:

• path – The path to the scenario file or folder.

• name – A short name for the scenario. If None, uses the file/folder name.

• source – The origin of this registration (‘negmas’ for built-in, library name for external, or ‘unknown’ if not specified).

• tags – Optional set of tags for categorization and filtering.

• normalized – Whether the scenario utilities are normalized.

• n_outcomes – The number of possible outcomes.

• n_negotiators – The number of negotiators in the scenario.

• anac – Whether this scenario is from an ANAC competition.

• has_stats – Whether the scenario has pre-computed statistics.

• has_plot – Whether the scenario has a pre-generated plot.

• read_only – Whether this scenario is read-only (cannot be unregistered).

• **extra – Additional properties to store.

Returns:

The ScenarioInfo object that was created.

Example

# Register a scenario folder register_scenario(

“/path/to/MyScenario”, tags={“custom”, “bilateral”}, n_negotiators=2,

)

# Register with auto-detection register_scenario(“/path/to/domain.xml”)

negmas.registry.save_registry(path: str | Path | None = None, *, include_mechanisms: bool = True, include_negotiators: bool = True, include_components: bool = True, include_scenarios: bool = True) → Path

Save all registries to a folder.

This function serializes the global registries (mechanisms, negotiators, components, and scenarios) to JSON files in the specified folder.

Note: Only metadata is saved. Class registrations store the full type name, so the classes must be importable when loading. Scenario registrations store the path, so the scenario files must exist when loading.

Parameters:

• path – The folder to save to. Defaults to ~/negmas/registry.

• include_mechanisms – Whether to save the mechanism registry.

• include_negotiators – Whether to save the negotiator registry.

• include_components – Whether to save the component registry.

• include_scenarios – Whether to save the scenario registry.

Returns:

The path where the registries were saved.

Example

# Save to default location save_registry()

# Save to custom location save_registry(“/path/to/my/registry”)

# Save only negotiators and scenarios save_registry(include_mechanisms=False, include_components=False)

negmas.registry.scenario_registry: ScenarioRegistry = {'/home/docs/checkouts/readthedocs.org/user_builds/negmas/checkouts/v0.15.3/src/negmas/scenarios/CameraB': ScenarioInfo(name='CameraB', path=PosixPath('/home/docs/checkouts/readthedocs.org/user_builds/negmas/checkouts/v0.15.3/src/negmas/scenarios/CameraB'), source='negmas', description='', tags={'builtin', 'bilateral', 'xml'}, n_outcomes=3600, n_negotiators=2, opposition_level=0.247616, rational_fraction=None, read_only=True, extra={})}

The global scenario registry.