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] = {'ACCombi#53b502fa': ComponentInfo(key='ACCombi#53b502fa', short_name='ACCombi', full_type_name='negmas.gb.components.acceptance.ACCombi', cls=<class 'negmas.gb.components.acceptance.ACCombi'>, source='negmas', description="The ACcombi acceptance condition of Baarslag et al. (2012/2013), used by the\nNice Tit for Tat agent.\n\nACcombi combines ACnext with a time-based fallback:\n\n* **ACnext**: accept the opponent's offer if it is at least as good as the\n  offer the bidding strategy was planning to propose next, i.e.\n  ``a * u(opp_offer) + b >= u(my_next_offer)``. The rationale is that if the\n  opponent's offer beats our own next planned offer, we have effectively\n  reached a consensus and should accept.\n* **ACtime**: when time is running out (``relative_time >= t``), accept the\n  offer rather than risk a breakdown — there is no expected improvement in\n  the little time left.\n\nAccepts if **either** condition holds.\n\nArgs:\n    offering_strategy: The offering policy used to determine our next\n        planned offer (its result is cached per step, so calling it here\n        does not duplicate the work done when we later propose).\n    a: Scaling factor on the opponent-offer utility (default ``1.0``).\n    b: Offset added to the scaled opponent-offer utility (default ``0.0``).\n    t: Relative-time threshold for the ACtime fallback (default ``0.99``).\n\nRemarks:\n    - If the offering strategy cannot produce a next offer, any rational\n      offer (at or above the reserved value) is accepted.\n\n*AI Generated (ACcombi acceptance condition for the Nice Tit for Tat agent).*", params={}, tags={'acceptance', 'combined', 'tit-for-tat', 'adaptive', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'ACConst#7b0aaa53': ComponentInfo(key='ACConst#7b0aaa53', 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={'acceptance', 'threshold', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'ACLast#5c6c70d1': ComponentInfo(key='ACLast#5c6c70d1', 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={'acceptance', 'adaptive', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'ACLastFractionReceived#46bbb1bf': ComponentInfo(key='ACLastFractionReceived#46bbb1bf', 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={'acceptance', 'adaptive', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'ACLastKReceived#bdbc5c03': ComponentInfo(key='ACLastKReceived#bdbc5c03', 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={'acceptance', 'adaptive', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'ACNext#03b4c5f1': ComponentInfo(key='ACNext#03b4c5f1', 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={'acceptance', 'adaptive', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'ACTime#3084ac94': ComponentInfo(key='ACTime#3084ac94', 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={'acceptance', 'time-based', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'ACTime#e90e8090': ComponentInfo(key='ACTime#e90e8090', 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={'acceptance', 'time-based', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'AcceptAbove#893342eb': ComponentInfo(key='AcceptAbove#893342eb', 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={'acceptance', 'threshold', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'AcceptAnyRational#2c2440b2': ComponentInfo(key='AcceptAnyRational#2c2440b2', 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={'acceptance', 'builtin', 'rational', 'sao'}, extra={}, component_type='acceptance'), 'AcceptAround#c778dd9b': ComponentInfo(key='AcceptAround#c778dd9b', 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={'acceptance', 'threshold', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'AcceptBest#1ccedf19': ComponentInfo(key='AcceptBest#1ccedf19', 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={'acceptance', 'optimal', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'AcceptBetterRational#053df2bc': ComponentInfo(key='AcceptBetterRational#053df2bc', 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={'acceptance', 'builtin', 'rational', 'sao'}, extra={}, component_type='acceptance'), 'AcceptBetween#1ed09141': ComponentInfo(key='AcceptBetween#1ed09141', 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={'acceptance', 'threshold', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'AcceptFinalOffer#390970cc': ComponentInfo(key='AcceptFinalOffer#390970cc', short_name='AcceptFinalOffer', full_type_name='negmas.gb.components.acceptance.AcceptFinalOffer', cls=<class 'negmas.gb.components.acceptance.AcceptFinalOffer'>, source='negmas', description='Accepts the final offer as long as it is above the reserved value', params={}, tags={'acceptance', 'time-based', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'AcceptImmediately#6c2b45e2': ComponentInfo(key='AcceptImmediately#6c2b45e2', 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={'acceptance', 'simple', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'AcceptNotWorseRational#813845ca': ComponentInfo(key='AcceptNotWorseRational#813845ca', 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={'acceptance', 'builtin', 'rational', 'sao'}, extra={}, component_type='acceptance'), 'AcceptTop#e9a9ff3c': ComponentInfo(key='AcceptTop#e9a9ff3c', 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={'acceptance', 'optimal', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'BayesianReservationValueModel#3f2d7196': ComponentInfo(key='BayesianReservationValueModel#3f2d7196', short_name='BayesianReservationValueModel', full_type_name='negmas.models.reservation.BayesianReservationValueModel', cls=<class 'negmas.models.reservation.BayesianReservationValueModel'>, source='negmas', description='Estimates the reservation value via Bayesian learning — Zeng & Sycara [205,206].\n\nA grid of candidate reservation values ``v`` is maintained with a posterior\nprobability each. The opponent is assumed to concede roughly linearly from its\nfirst observed offer toward its reservation value by the deadline, so the expected\nutility at time ``t`` under candidate ``v`` is ``e_v(t) = v + (u_0 - v)(1 - t)``.\nEach observation updates the posterior by a Gaussian likelihood around ``e_v(t)``\n(accumulated in log-space). The estimate is the posterior-weighted mean candidate.\n\nArgs:\n    candidates: Number of candidate reservation values in the ``[0, 1]`` grid.\n    sigma: Standard deviation of the observation-likelihood Gaussian.\n    min_observations: Minimum observations before an estimate is returned.\n\n*AI Generated (Zeng & Sycara Bayesian reservation-value estimator).*', params={}, tags={'bayesian', 'reservation-model', 'builtin', 'survey'}, extra={}, component_type='reservation-model'), 'CABOfferingPolicy#662b0155': ComponentInfo(key='CABOfferingPolicy#662b0155', short_name='CABOfferingPolicy', full_type_name='negmas.gb.components.offering.CABOfferingPolicy', cls=<class 'negmas.gb.components.offering.CABOfferingPolicy'>, source='negmas', description='CABOffering policy implementation.', params={}, tags={'offering', 'builtin', 'rational', 'sao'}, extra={}, component_type='offering'), 'CandidateEliminationModel#4bb82812': ComponentInfo(key='CandidateEliminationModel#4bb82812', short_name='CandidateEliminationModel', full_type_name='negmas.gb.components.models.heuristic.CandidateEliminationModel', cls=<class 'negmas.gb.components.models.heuristic.CandidateEliminationModel'>, source='negmas', description='Ordinal opponent model via candidate elimination (survey §5.3.4).\n\nCandidate elimination [8,9] is an inductive-learning algorithm that assumes\nonly that the opponent\'s preferences do not change during the negotiation.\nEach offer the opponent *sends* is a positive instance (its values are\nacceptable to the opponent); each of our own offers that the opponent\n*rejects* (i.e. counters instead of accepting) is a negative instance\n(something in it is unacceptable).\n\nA full version space over whole offers is exponential, so — as the survey\nnotes such models "only learn part of the relationships" — this is a\nper-issue rendition: for each issue it keeps the set of values seen in the\nopponent\'s offers (acceptable) and the set seen only in rejected offers of\nours (suspect). The estimated ordinal utility of an offer is the mean\nper-issue score, where a value is scored ``1`` if confirmed acceptable, ``0``\nif only ever seen in a rejected offer, and ``0.5`` if not yet seen (the\ngeneral-boundary default: unseen values may still be acceptable).\n\nNegatives are derived automatically: whenever the opponent makes a new offer,\nour most recent proposal is treated as rejected. They can also be supplied\nexplicitly via :meth:`note_rejected`.\n\nRemarks:\n    - This is an *ordinal* model — the values it returns rank outcomes but are\n      not calibrated cardinal utilities.\n    - Returns ``0.5`` for every outcome until some evidence is gathered.\n\n*AI Generated (candidate-elimination acceptable-offer model).*', params={}, tags={'ordinal', 'learning', 'model', 'heuristic', 'builtin', 'survey', 'sao'}, extra={}, component_type='model'), 'ConcessionExtrapolatingDeadlineModel#50f69fcd': ComponentInfo(key='ConcessionExtrapolatingDeadlineModel#50f69fcd', short_name='ConcessionExtrapolatingDeadlineModel', full_type_name='negmas.models.deadline.ConcessionExtrapolatingDeadlineModel', cls=<class 'negmas.models.deadline.ConcessionExtrapolatingDeadlineModel'>, source='negmas', description="Estimates the deadline by extrapolating the opponent's concession curve.\n\nA straight line is fit (least squares) to the observed ``(relative_time,\nopponent_utility)`` trace, then extrapolated to find the time at which the opponent's\nutility reaches its reservation value. This is the simplest instance of the family of\nmethods described in survey §5.1.1/§5.2 (Hou; Yu et al.; Sim et al.), which assume the\nopponent uses a time-dependent concession tactic.", params={}, tags={'regression', 'deadline-model', 'builtin', 'survey', 'concession'}, extra={}, component_type='deadline-model'), 'ConcessionExtrapolatingReservationModel#7834b544': ComponentInfo(key='ConcessionExtrapolatingReservationModel#7834b544', short_name='ConcessionExtrapolatingReservationModel', full_type_name='negmas.models.reservation.ConcessionExtrapolatingReservationModel', cls=<class 'negmas.models.reservation.ConcessionExtrapolatingReservationModel'>, source='negmas', description='Estimates the reservation value by extrapolating the concession curve.\n\nA straight line is fit (least squares) to the observed ``(relative_time,\nopponent_utility)`` trace and extrapolated to the deadline (``t = 1``); the\nutility there is taken as the reservation value. This is the simplest instance of\nthe regression family of survey §5.1.1 (Hou [85]; Yu et al. [204]), which assume\nthe opponent uses a time-dependent concession tactic.\n\n*AI Generated (regression-based reservation-value estimator).*', params={}, tags={'regression', 'concession', 'builtin', 'reservation-model', 'survey'}, extra={}, component_type='reservation-model'), 'ConcessionRatioUFunModel#27704345': ComponentInfo(key='ConcessionRatioUFunModel#27704345', short_name='ConcessionRatioUFunModel', full_type_name='negmas.gb.components.models.weights.ConcessionRatioUFunModel', cls=<class 'negmas.gb.components.models.weights.ConcessionRatioUFunModel'>, source='negmas', description="Issue weights from concession ratios — Niemann & Lang [143] (survey §5.3.1).\n\nFor each issue a *concession ratio* ``c_i`` is the fraction of consecutive\noffer pairs in which the opponent changed that issue's value. The more an\nissue is conceded on, the less important it is assumed to be, so the issue\nweight is ``w_i = 1 - c_i`` (then normalized across issues). Per-issue value\nutilities are estimated from offer frequency.\n\nRemarks:\n    - The survey's method updates a Bayesian posterior over weight\n      hypotheses; here ``1 - c_i`` is used directly as a deterministic\n      maximum-likelihood rendition (no explicit posterior), which keeps the\n      model domain-agnostic and online.\n    - Returns utilities already normalized to ``[0, 1]``; a neutral ``0.5``\n      before any offer is observed.\n\n*AI Generated (Niemann & Lang concession-ratio issue weights).*", params={}, tags={'learning', 'issue-weights', 'model', 'linear', 'builtin', 'survey', 'sao'}, extra={}, component_type='model'), 'DerivativeOfferingModel#2da3d65e': ComponentInfo(key='DerivativeOfferingModel#2da3d65e', short_name='DerivativeOfferingModel', full_type_name='negmas.models.strategy.DerivativeOfferingModel', cls=<class 'negmas.models.strategy.DerivativeOfferingModel'>, source='negmas', description="Forecasts the opponent's offers from the derivatives of its concession curve.\n\nA time-series-forecasting offering-strategy model (survey §5.4.2) following\nBrzostowski et al. [29]. Finite differences of the observed concession curve\nestimate its local first and second derivatives, which are extrapolated\n(second-order Taylor step) to forecast future offers. The model also exposes a\n:meth:`time_influence` metric — the sign-consistency of the differences (survey\neq. 8) — measuring how strongly the opponent behaves like a pure time-dependent\ntactician (``1`` = perfectly consistent, ``0`` = inconsistent).\n\nArgs:\n    min_observations: Minimum observations before extrapolation is used; below\n        it :meth:`predict_utility` falls back to the last observed utility.\n\n*AI Generated (Brzostowski et al. derivative-based offer forecaster).*", params={}, tags={'derivatives', 'time-series', 'offering-model', 'builtin', 'survey'}, extra={}, component_type='offering-model'), 'EndImmediately#8ee0271f': ComponentInfo(key='EndImmediately#8ee0271f', 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={'acceptance', 'simple', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'FastMiCROOfferingPolicy#ad822155': ComponentInfo(key='FastMiCROOfferingPolicy#ad822155', short_name='FastMiCROOfferingPolicy', full_type_name='negmas.gb.components.offering.FastMiCROOfferingPolicy', cls=<class 'negmas.gb.components.offering.FastMiCROOfferingPolicy'>, source='negmas', description='FastMiCROOffering policy implementation.\n\nLike `MiCROOfferingPolicy` but able to *skip* outcomes so that the whole\noutcome list can be traversed before the deadline.\n\nArgs:\n    forced_concession_time: Relative time after which concession is allowed\n        even if we have already sent more offers than we received.\n    min_time_before_skipping: Skipping is disabled before this relative time\n        (the concession-rate estimate is too noisy that early).\n    min_offers_before_skipping: Skipping is disabled until at least this many\n        offers have been sent.\n    expected_offers_rounding: Added before truncating the estimated number of\n        remaining offers (``0.5`` rounds to nearest).', params={}, tags={'offering', 'builtin', 'micro', 'sao'}, extra={}, component_type='offering'), 'FrequencyLinearUFunModel#4837f212': ComponentInfo(key='FrequencyLinearUFunModel#4837f212', short_name='FrequencyLinearUFunModel', full_type_name='negmas.gb.components.models.ufun.FrequencyLinearUFunModel', cls=<class 'negmas.gb.components.models.ufun.FrequencyLinearUFunModel'>, source='negmas', description="A frequency-based opponent model that **assumes the opponent's utility\nfunction is `LinearAdditiveUtilityFunction`** (a weighted sum of per-issue\nvalue utilities) — the assumption used by the Bayesian opponent model of\nHindriks & Tykhonov (2008), and hence the default opponent model for the\nNice Tit for Tat agent.\n\nIt estimates the opponent's preference for an issue value from how often\nthe opponent has *offered* that value (values offered more frequently are\nassumed more preferred) and combines issues with learned weights: an issue\nwhose offered-value distribution is more concentrated receives a higher\nweight (``weight = 1 - normalized_entropy`` of the value counts). The\nestimated utility is the weighted sum of the per-issue value scores — a\nlinear-additive aggregation.\n\nThe model is updated from every offer the negotiator responds to\n(``before_responding``) and, when the mechanism enables callbacks, from\n``on_partner_proposal``.\n\nArgs:\n    above_reserve: Kept for interface compatibility with `ZeroSumModel`.\n    levels: Number of grid values used to discretize continuous issues (so\n        they contribute frequency counts instead of being ignored).\n\nRemarks:\n    - Continuous issues are discretized to ``levels`` grid values (via\n      `Issue.to_discrete`); offered values are snapped to the nearest grid\n      value for counting. Already-discrete issues are used as-is.\n    - Returns utilities in ``[0, 1]`` (already normalized).\n    - Before any opponent offer is observed, returns a neutral ``0.5`` for\n      every outcome (so a Nice Tit for Tat offering strategy falls back to\n      mirroring until the model has learned).\n\n*AI Generated (linear-additive frequency opponent model).*", params={}, tags={'learning', 'frequency', 'model', 'linear', 'builtin', 'sao'}, extra={}, component_type='model'), 'FrequencyUFunModel#623be694': ComponentInfo(key='FrequencyUFunModel#623be694', short_name='FrequencyUFunModel', full_type_name='negmas.gb.components.models.ufun.FrequencyUFunModel', cls=<class 'negmas.gb.components.models.ufun.FrequencyUFunModel'>, source='negmas', description="A frequency-based opponent model that makes **no assumption** about the form\nof the opponent's utility function (use this when the opponent's ufun is\n*not* known to be linear-additive).\n\nIt counts how often the opponent has offered each complete outcome and\nestimates the opponent's utility of an outcome as its offer frequency\nnormalized by the maximum observed frequency. Outcomes never offered score\n``0``. Before any offer is observed, every outcome scores a neutral ``0.5``.\n\nThe model is updated from every offer the negotiator responds to\n(``before_responding``) and, when the mechanism enables callbacks, from\n``on_partner_proposal``.\n\nRemarks:\n    - Returns utilities in ``[0, 1]`` (already normalized).\n    - Sparse: only outcomes actually offered get a positive score, so this\n      model is best suited to small/discrete outcome spaces. For larger\n      spaces with an additive opponent ufun, prefer\n      `FrequencyLinearUFunModel`.\n\n*AI Generated (frequency-based opponent model).*", params={}, tags={'learning', 'frequency', 'model', 'builtin', 'sao'}, extra={}, component_type='model'), 'GACABMP#61a38730': ComponentInfo(key='GACABMP#61a38730', short_name='GACABMP', full_type_name='negmas.gb.components.genius.acceptance.anac2010.GACABMP', cls=<class 'negmas.gb.components.genius.acceptance.anac2010.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={'acceptance', 'genius', 'gb', 'anac2010', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACAgentFSEGA#59a8f559': ComponentInfo(key='GACAgentFSEGA#59a8f559', short_name='GACAgentFSEGA', full_type_name='negmas.gb.components.genius.acceptance.anac2010.GACAgentFSEGA', cls=<class 'negmas.gb.components.genius.acceptance.anac2010.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    max_utility: The assumed maximum utility in the domain (default 1.0,\n        i.e. a normalized ufun).\n    max_utility_tolerance: Fraction of ``max_utility`` above which an offer\n        counts as "close to max" and is accepted (default 0.999).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2010.AC_AgentFSEGA', params={}, tags={'acceptance', 'genius', 'gb', 'anac2010', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACAgentK#45c66e69': ComponentInfo(key='GACAgentK#45c66e69', short_name='GACAgentK', full_type_name='negmas.gb.components.genius.acceptance.anac2010.GACAgentK', cls=<class 'negmas.gb.components.genius.acceptance.anac2010.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\nArgs:\n    expected_utility_decay: How much the expected utility drops over the full\n        negotiation (``expected = 1 - decay * t``). Defaults to ``0.5``.\n    time_pressure_exponent: Exponent applied to relative time when computing\n        time pressure. Defaults to ``2.0``.\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2010.AC_AgentK", params={}, tags={'acceptance', 'genius', 'gb', 'anac2010', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACAgentK2#a1d5dc45': ComponentInfo(key='GACAgentK2#a1d5dc45', short_name='GACAgentK2', full_type_name='negmas.gb.components.genius.acceptance.anac2011.GACAgentK2', cls=<class 'negmas.gb.components.genius.acceptance.anac2011.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\nArgs:\n    base_accept_probability: Acceptance probability at ``t=0`` for an offer\n        that already meets expectations (default 0.5).\n    time_accept_weight: How much relative time adds to that probability\n        (default 0.5, so it reaches 1.0 at the deadline).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_AgentK2', params={}, tags={'acceptance', 'genius', 'gb', 'ai-generated', 'boa', 'genius-translated', 'anac2011'}, extra={}, component_type='acceptance'), 'GACAgentLG#b54bd977': ComponentInfo(key='GACAgentLG#b54bd977', short_name='GACAgentLG', full_type_name='negmas.gb.components.genius.acceptance.anac2012.GACAgentLG', cls=<class 'negmas.gb.components.genius.acceptance.anac2012.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    min_acceptable_floor: Lower bound on the adaptive minimum acceptable\n        utility (default 0.5).\n    min_acceptable_base: Value of the adaptive minimum at ``t=0``\n        (default 0.9).\n    min_acceptable_decay: How much that minimum drops over the full\n        negotiation (default 0.3).\n    endgame_time: Relative time after which ``endgame_ratio`` applies\n        (default 0.999).\n    endgame_ratio: Fraction of our own last utility accepted in the endgame\n        (default 0.9).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2012.AC_AgentLG', params={}, tags={'acceptance', 'genius', 'gb', 'anac2012', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACAgentMR#9d63fcba': ComponentInfo(key='GACAgentMR#9d63fcba', short_name='GACAgentMR', full_type_name='negmas.gb.components.genius.acceptance.anac2012.GACAgentMR', cls=<class 'negmas.gb.components.genius.acceptance.anac2012.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    sigmoid_gain: Gain of the sigmoid controlling how the minimum bid utility\n        decreases with time (default -5.0).\n    sigmoid_percent: Total drop of the minimum bid utility across the\n        negotiation (default 0.70).\n    sigmoid_midpoint: Relative time at the sigmoid's midpoint (default 0.5).\n    sigmoid_base: Base of the sigmoid's power term (default 10).\n    time_exponent: Exponent applied to relative time in the acceptance\n        probability, making it rise steeply near the deadline (default 3).\n    max_utility: Utilities above this are rejected outright as out of range\n        (default 1.05).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2012.AC_AgentMR", params={}, tags={'acceptance', 'genius', 'gb', 'anac2012', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACAgentSmith#16f2280b': ComponentInfo(key='GACAgentSmith#16f2280b', short_name='GACAgentSmith', full_type_name='negmas.gb.components.genius.acceptance.anac2010.GACAgentSmith', cls=<class 'negmas.gb.components.genius.acceptance.anac2010.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={'acceptance', 'genius', 'gb', 'anac2010', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACBRAMAgent#bb84e595': ComponentInfo(key='GACBRAMAgent#bb84e595', short_name='GACBRAMAgent', full_type_name='negmas.gb.components.genius.acceptance.anac2011.GACBRAMAgent', cls=<class 'negmas.gb.components.genius.acceptance.anac2011.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    min_threshold: Acceptance threshold at the deadline (default 0.5).\n    max_threshold: Acceptance threshold at ``t=0`` (default 0.95).\n    threshold_exponent: Exponent applied to relative time when interpolating\n        between ``max_threshold`` and ``min_threshold`` (default 2).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_BRAMAgent', params={}, tags={'acceptance', 'genius', 'gb', 'ai-generated', 'boa', 'genius-translated', 'anac2011'}, extra={}, component_type='acceptance'), 'GACBRAMAgent2#db8a5256': ComponentInfo(key='GACBRAMAgent2#db8a5256', short_name='GACBRAMAgent2', full_type_name='negmas.gb.components.genius.acceptance.anac2012.GACBRAMAgent2', cls=<class 'negmas.gb.components.genius.acceptance.anac2012.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    base_threshold: Acceptance threshold at ``t=0`` (default 0.95).\n    threshold_range: How much the threshold falls by the deadline\n        (default 0.4).\n    threshold_exponent: Exponent applied to relative time (default 2).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2012.AC_BRAMAgent2', params={}, tags={'acceptance', 'genius', 'gb', 'anac2012', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCUHKAgent#4a7f1d56': ComponentInfo(key='GACCUHKAgent#4a7f1d56', short_name='GACCUHKAgent', full_type_name='negmas.gb.components.genius.acceptance.anac2012.GACCUHKAgent', cls=<class 'negmas.gb.components.genius.acceptance.anac2012.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    base_threshold: Threshold at ``t=0`` (default 0.95).\n    concede_factor: Exponent applied to relative time when interpolating\n        between ``base_threshold`` and ``min_threshold`` (default 0.9).\n    endgame_time: Relative time after which the opponent-max rule applies\n        (default 0.9985).\n    endgame_slack: Slack subtracted from the observed opponent max in the\n        endgame (default 0.01).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2012.AC_CUHKAgent', params={}, tags={'acceptance', 'genius', 'gb', 'anac2012', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombi#355fe516': ComponentInfo(key='GACCombi#355fe516', short_name='GACCombi', full_type_name='negmas.gb.components.genius.acceptance.combi.GACCombi', cls=<class 'negmas.gb.components.genius.acceptance.combi.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={'acceptance', 'genius', 'gb', 'combined', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiAvg#61752f76': ComponentInfo(key='GACCombiAvg#61752f76', short_name='GACCombiAvg', full_type_name='negmas.gb.components.genius.acceptance.combi.GACCombiAvg', cls=<class 'negmas.gb.components.genius.acceptance.combi.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={'acceptance', 'genius', 'gb', 'combined', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiBestAvg#9677a484': ComponentInfo(key='GACCombiBestAvg#9677a484', short_name='GACCombiBestAvg', full_type_name='negmas.gb.components.genius.acceptance.combi.GACCombiBestAvg', cls=<class 'negmas.gb.components.genius.acceptance.combi.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={'acceptance', 'genius', 'gb', 'combined', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiBestAvgDiscounted#51a1267c': ComponentInfo(key='GACCombiBestAvgDiscounted#51a1267c', short_name='GACCombiBestAvgDiscounted', full_type_name='negmas.gb.components.genius.acceptance.combi_variants.GACCombiBestAvgDiscounted', cls=<class 'negmas.gb.components.genius.acceptance.combi_variants.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={'acceptance', 'genius', 'gb', 'discounted', 'combined', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiMax#f2f155bc': ComponentInfo(key='GACCombiMax#f2f155bc', short_name='GACCombiMax', full_type_name='negmas.gb.components.genius.acceptance.combi.GACCombiMax', cls=<class 'negmas.gb.components.genius.acceptance.combi.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={'acceptance', 'genius', 'gb', 'combined', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiMaxInWindow#eb20bba3': ComponentInfo(key='GACCombiMaxInWindow#eb20bba3', short_name='GACCombiMaxInWindow', full_type_name='negmas.gb.components.genius.acceptance.combi.GACCombiMaxInWindow', cls=<class 'negmas.gb.components.genius.acceptance.combi.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={'acceptance', 'genius', 'gb', 'windowed', 'combined', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiMaxInWindowDiscounted#06e95289': ComponentInfo(key='GACCombiMaxInWindowDiscounted#06e95289', short_name='GACCombiMaxInWindowDiscounted', full_type_name='negmas.gb.components.genius.acceptance.combi_variants.GACCombiMaxInWindowDiscounted', cls=<class 'negmas.gb.components.genius.acceptance.combi_variants.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={'acceptance', 'windowed', 'genius-translated', 'genius', 'gb', 'discounted', 'combined', 'ai-generated', 'boa'}, extra={}, component_type='acceptance'), 'GACCombiProb#c0385d48': ComponentInfo(key='GACCombiProb#c0385d48', short_name='GACCombiProb', full_type_name='negmas.gb.components.genius.acceptance.combi_variants.GACCombiProb', cls=<class 'negmas.gb.components.genius.acceptance.combi_variants.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={'probabilistic', 'genius', 'gb', 'acceptance', 'combined', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiProbDiscounted#0e122581': ComponentInfo(key='GACCombiProbDiscounted#0e122581', short_name='GACCombiProbDiscounted', full_type_name='negmas.gb.components.genius.acceptance.combi_variants.GACCombiProbDiscounted', cls=<class 'negmas.gb.components.genius.acceptance.combi_variants.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={'probabilistic', 'acceptance', 'genius-translated', 'genius', 'gb', 'discounted', 'combined', 'ai-generated', 'boa'}, extra={}, component_type='acceptance'), 'GACCombiV2#890739ea': ComponentInfo(key='GACCombiV2#890739ea', short_name='GACCombiV2', full_type_name='negmas.gb.components.genius.acceptance.combi_variants.GACCombiV2', cls=<class 'negmas.gb.components.genius.acceptance.combi_variants.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={'acceptance', 'genius', 'gb', 'combined', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiV3#bb9e2b8c': ComponentInfo(key='GACCombiV3#bb9e2b8c', short_name='GACCombiV3', full_type_name='negmas.gb.components.genius.acceptance.combi_variants.GACCombiV3', cls=<class 'negmas.gb.components.genius.acceptance.combi_variants.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={'acceptance', 'genius', 'gb', 'combined', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACCombiV4#88ada8e3': ComponentInfo(key='GACCombiV4#88ada8e3', short_name='GACCombiV4', full_type_name='negmas.gb.components.genius.acceptance.combi_variants.GACCombiV4', cls=<class 'negmas.gb.components.genius.acceptance.combi_variants.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={'acceptance', 'genius', 'gb', 'combined', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACConst#53c6a34e': ComponentInfo(key='GACConst#53c6a34e', short_name='GACConst', full_type_name='negmas.gb.components.genius.acceptance.base_conditions.GACConst', cls=<class 'negmas.gb.components.genius.acceptance.base_conditions.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={'acceptance', 'genius', 'gb', 'ai-generated', 'boa', 'genius-translated', 'threshold'}, extra={}, component_type='acceptance'), 'GACConstDiscounted#73e3169e': ComponentInfo(key='GACConstDiscounted#73e3169e', short_name='GACConstDiscounted', full_type_name='negmas.gb.components.genius.acceptance.base_conditions.GACConstDiscounted', cls=<class 'negmas.gb.components.genius.acceptance.base_conditions.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={'acceptance', 'genius', 'gb', 'discounted', 'ai-generated', 'boa', 'genius-translated', 'threshold'}, extra={}, component_type='acceptance'), 'GACFalse#36460417': ComponentInfo(key='GACFalse#36460417', short_name='GACFalse', full_type_name='negmas.gb.components.genius.acceptance.base_conditions.GACFalse', cls=<class 'negmas.gb.components.genius.acceptance.base_conditions.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={'acceptance', 'genius', 'gb', 'simple', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACGahboninho#8400ac83': ComponentInfo(key='GACGahboninho#8400ac83', short_name='GACGahboninho', full_type_name='negmas.gb.components.genius.acceptance.anac2011.GACGahboninho', cls=<class 'negmas.gb.components.genius.acceptance.anac2011.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    early_phase_end: Relative time before which ``high_threshold`` alone\n        triggers acceptance (default 0.5).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_Gahboninho', params={}, tags={'acceptance', 'genius', 'gb', 'ai-generated', 'boa', 'genius-translated', 'anac2011'}, extra={}, component_type='acceptance'), 'GACGap#08becc00': ComponentInfo(key='GACGap#08becc00', short_name='GACGap', full_type_name='negmas.gb.components.genius.acceptance.base_conditions.GACGap', cls=<class 'negmas.gb.components.genius.acceptance.base_conditions.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={'acceptance', 'genius', 'gb', 'ai-generated', 'boa', 'genius-translated', 'adaptive'}, extra={}, component_type='acceptance'), 'GACHardHeaded#d4db2d82': ComponentInfo(key='GACHardHeaded#d4db2d82', short_name='GACHardHeaded', full_type_name='negmas.gb.components.genius.acceptance.anac2011.GACHardHeaded', cls=<class 'negmas.gb.components.genius.acceptance.anac2011.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={'acceptance', 'genius', 'gb', 'ai-generated', 'boa', 'genius-translated', 'anac2011'}, extra={}, component_type='acceptance'), 'GACIAMCrazyHaggler#6039905b': ComponentInfo(key='GACIAMCrazyHaggler#6039905b', short_name='GACIAMCrazyHaggler', full_type_name='negmas.gb.components.genius.acceptance.anac2010.GACIAMCrazyHaggler', cls=<class 'negmas.gb.components.genius.acceptance.anac2010.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={'acceptance', 'genius', 'gb', 'anac2010', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACIAMHaggler2010#7dc39dab': ComponentInfo(key='GACIAMHaggler2010#7dc39dab', short_name='GACIAMHaggler2010', full_type_name='negmas.gb.components.genius.acceptance.anac2010.GACIAMHaggler2010', cls=<class 'negmas.gb.components.genius.acceptance.anac2010.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={'acceptance', 'genius', 'gb', 'anac2010', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACIAMHaggler2011#e3c34cba': ComponentInfo(key='GACIAMHaggler2011#e3c34cba', short_name='GACIAMHaggler2011', full_type_name='negmas.gb.components.genius.acceptance.anac2011.GACIAMHaggler2011', cls=<class 'negmas.gb.components.genius.acceptance.anac2011.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={'acceptance', 'genius', 'gb', 'ai-generated', 'boa', 'genius-translated', 'anac2011'}, extra={}, component_type='acceptance'), 'GACIAMHaggler2012#62021ada': ComponentInfo(key='GACIAMHaggler2012#62021ada', short_name='GACIAMHaggler2012', full_type_name='negmas.gb.components.genius.acceptance.anac2012.GACIAMHaggler2012', cls=<class 'negmas.gb.components.genius.acceptance.anac2012.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={'acceptance', 'genius', 'gb', 'anac2012', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACInoxAgent#a3a8a75e': ComponentInfo(key='GACInoxAgent#a3a8a75e', short_name='GACInoxAgent', full_type_name='negmas.gb.components.genius.acceptance.anac2013_other.GACInoxAgent', cls=<class 'negmas.gb.components.genius.acceptance.anac2013_other.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    median_util: Median-utility estimate used as the concession floor\n        (default 0.5).\n    close_enough: Accept when our worst bid is within this much of the\n        opponent's offer (default 0.05).\n    time_diff_window: Number of recent inter-round time differences averaged\n        when estimating the rounds left (default 10).\n    endgame_rounds_left: Once fewer than this many rounds are estimated to\n        remain, accept at the concession floor (default 8).\n    start_val: Acceptance threshold at ``t=0`` (default 1.0).\n    concession_power: Exponent applied to relative time - very large values\n        keep the threshold near ``start_val`` until the very end\n        (default 27).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2013.AC_InoxAgent", params={}, tags={'acceptance', 'genius', 'gb', 'anac2013', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACInoxAgentOneIssue#e86f5583': ComponentInfo(key='GACInoxAgentOneIssue#e86f5583', short_name='GACInoxAgentOneIssue', full_type_name='negmas.gb.components.genius.acceptance.anac2013_other.GACInoxAgentOneIssue', cls=<class 'negmas.gb.components.genius.acceptance.anac2013_other.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    median_util: Median-utility threshold at or above which an offer is\n        accepted (default 0.5).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2013.AC_InoxAgent_OneIssue", params={}, tags={'acceptance', 'genius', 'gb', 'anac2013', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACMAC#c39a7bba': ComponentInfo(key='GACMAC#c39a7bba', short_name='GACMAC', full_type_name='negmas.gb.components.genius.acceptance.anac2013_other.GACMAC', cls=<class 'negmas.gb.components.genius.acceptance.anac2013_other.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={'multi-attribute', 'genius', 'gb', 'acceptance', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACNext#eb77335b': ComponentInfo(key='GACNext#eb77335b', short_name='GACNext', full_type_name='negmas.gb.components.genius.acceptance.base_conditions.GACNext', cls=<class 'negmas.gb.components.genius.acceptance.base_conditions.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={'acceptance', 'genius', 'gb', 'ai-generated', 'boa', 'genius-translated', 'adaptive'}, extra={}, component_type='acceptance'), 'GACNiceTitForTat#85b037ff': ComponentInfo(key='GACNiceTitForTat#85b037ff', short_name='GACNiceTitForTat', full_type_name='negmas.gb.components.genius.acceptance.anac2011.GACNiceTitForTat', cls=<class 'negmas.gb.components.genius.acceptance.anac2011.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    endgame_start: Relative time from which the probabilistic (expected\n        utility of waiting) rule kicks in. Before it, only AC_Next applies\n        (default 0.98).\n    min_time_left: Minimum remaining relative time for which we still hold\n        out for a better offer we have already seen (default 0.001).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_NiceTitForTat', params={}, tags={'acceptance', 'genius', 'gb', 'ai-generated', 'tit-for-tat', 'boa', 'genius-translated', 'anac2011'}, extra={}, component_type='acceptance'), 'GACNozomi#fb35fd2a': ComponentInfo(key='GACNozomi#fb35fd2a', short_name='GACNozomi', full_type_name='negmas.gb.components.genius.acceptance.anac2010.GACNozomi', cls=<class 'negmas.gb.components.genius.acceptance.anac2010.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    phase1_end: Relative time at which the early phase ends (default 0.50).\n    phase2_end: Relative time at which the middle phase ends (default 0.80).\n    phase1_coeff_slope: Slope of the early-phase acceptance coefficient\n        ``slope * t + intercept`` (default -0.1).\n    phase1_coeff_intercept: Intercept of the early-phase coefficient\n        (default 1.0).\n    phase2_coeff_slope: Slope of the middle-phase coefficient\n        ``slope * (t - phase1_end) + intercept`` (default -0.16).\n    phase2_coeff_intercept: Intercept of the middle-phase coefficient\n        (default 0.95).\n    phase2_compromise_factor: Fraction of the max compromise utility an\n        offer must beat in the middle phase (default 0.95).\n    phase3_compromise_factor: Same, for the late phase (default 0.90).\n    phase3_split_time: Relative time splitting the late phase into its\n        early and final parts (default 0.90).\n    phase3_early_discount: Discount applied to our last utility in the early\n        part of the late phase (default 0.40).\n    phase3_late_discount: Same, for the final part (default 0.50).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2010.AC_Nozomi', params={}, tags={'acceptance', 'genius', 'gb', 'anac2010', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACOMACagent#e6522324': ComponentInfo(key='GACOMACagent#e6522324', short_name='GACOMACagent', full_type_name='negmas.gb.components.genius.acceptance.anac2012.GACOMACagent', cls=<class 'negmas.gb.components.genius.acceptance.anac2012.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    endgame_time: Relative time after which a repeated bid is accepted\n        (default 0.97).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2012.AC_OMACagent", params={}, tags={'acceptance', 'genius', 'gb', 'anac2012', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACPrevious#bad299e6': ComponentInfo(key='GACPrevious#bad299e6', short_name='GACPrevious', full_type_name='negmas.gb.components.genius.acceptance.base_conditions.GACPrevious', cls=<class 'negmas.gb.components.genius.acceptance.base_conditions.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={'acceptance', 'genius', 'gb', 'ai-generated', 'boa', 'genius-translated', 'adaptive'}, extra={}, component_type='acceptance'), 'GACTheFawkes#46d186e4': ComponentInfo(key='GACTheFawkes#46d186e4', short_name='GACTheFawkes', full_type_name='negmas.gb.components.genius.acceptance.anac2013_other.GACTheFawkes', cls=<class 'negmas.gb.components.genius.acceptance.anac2013_other.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    min_acceptable: Minimum utility below which an offer is rejected outright\n        (default 0.5).\n    max_time_diff: Width of the near-deadline window, i.e. the rule fires\n        once ``t >= 1 - max_time_diff`` (default 0.01).\n    window_scale: The window covers ``len(offers) * max_time_diff *\n        window_scale`` of the most recent partner offers (default 10).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2013.AC_TheFawkes", params={}, tags={'acceptance', 'genius', 'gb', 'anac2013', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACTheNegotiator#eb7bbfc9': ComponentInfo(key='GACTheNegotiator#eb7bbfc9', short_name='GACTheNegotiator', full_type_name='negmas.gb.components.genius.acceptance.anac2011.GACTheNegotiator', cls=<class 'negmas.gb.components.genius.acceptance.anac2011.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\nArgs:\n    phase1_end: Relative time ending the hardball phase (default 0.3).\n    phase2_end: Relative time ending the conceding phase (default 0.7).\n    phase1_threshold: Acceptance threshold during hardball (default 0.95).\n    phase2_threshold: Threshold at the start of the conceding phase\n        (default 0.85), decaying at ``phase2_decay``.\n    phase2_decay: Per-unit-time decay of the conceding threshold\n        (default 0.25).\n    phase3_threshold: Threshold at the start of the desperate phase\n        (default 0.70), decaying at ``phase3_decay``.\n    phase3_decay: Per-unit-time decay of the desperate threshold\n        (default 0.3).\n    desperate_moves_left: In the desperate phase, once fewer than this many\n        moves are estimated to remain, anything is accepted (default 15).\n    default_moves_left: Moves-left estimate used when it cannot be computed\n        (default 100).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_TheNegotiator', params={}, tags={'acceptance', 'genius', 'gb', 'ai-generated', 'boa', 'genius-translated', 'anac2011'}, extra={}, component_type='acceptance'), 'GACTheNegotiatorReloaded#00ee8fa0': ComponentInfo(key='GACTheNegotiatorReloaded#00ee8fa0', short_name='GACTheNegotiatorReloaded', full_type_name='negmas.gb.components.genius.acceptance.anac2012.GACTheNegotiatorReloaded', cls=<class 'negmas.gb.components.genius.acceptance.anac2012.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    window_divisor: The panic-phase window covers the most recent\n        ``len(offers) // window_divisor`` partner offers (default 4).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2012.AC_TheNegotiatorReloaded', params={}, tags={'acceptance', 'genius', 'gb', 'anac2012', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACTime#060226f4': ComponentInfo(key='GACTime#060226f4', short_name='GACTime', full_type_name='negmas.gb.components.genius.acceptance.base_conditions.GACTime', cls=<class 'negmas.gb.components.genius.acceptance.base_conditions.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={'acceptance', 'genius', 'gb', 'ai-generated', 'boa', 'genius-translated', 'time-based'}, extra={}, component_type='acceptance'), 'GACTrue#bc73bf2f': ComponentInfo(key='GACTrue#bc73bf2f', short_name='GACTrue', full_type_name='negmas.gb.components.genius.acceptance.base_conditions.GACTrue', cls=<class 'negmas.gb.components.genius.acceptance.base_conditions.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={'acceptance', 'genius', 'gb', 'simple', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACUncertain#3076439f': ComponentInfo(key='GACUncertain#3076439f', short_name='GACUncertain', full_type_name='negmas.gb.components.genius.acceptance.anac2013_other.GACUncertain', cls=<class 'negmas.gb.components.genius.acceptance.anac2013_other.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={'acceptance', 'genius', 'gb', 'uncertainty', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GACValueModelAgent#306cb405': ComponentInfo(key='GACValueModelAgent#306cb405', short_name='GACValueModelAgent', full_type_name='negmas.gb.components.genius.acceptance.anac2011.GACValueModelAgent', cls=<class 'negmas.gb.components.genius.acceptance.anac2011.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\nArgs:\n    lowest_approved: Lowest utility considered approved (default 0.9).\n    planned_threshold: Planned acceptance threshold (default 0.85).\n    window_start: Start of the near-deadline acceptance window\n        (default 0.98).\n    window_end: End of that window (default 0.99).\n    window_slack: Slack subtracted from ``lowest_approved`` inside the\n        window (default 0.01).\n    final_time: Relative time after which the opponent-max rule applies\n        (default 0.995).\n    final_opponent_max_min: Minimum observed opponent-max utility required\n        for that rule (default 0.55).\n    final_opponent_max_factor: Fraction of the observed opponent max that an\n        offer must reach (default 0.99).\n    settled_threshold: Absolute utility above which a settled offer is\n        accepted (default 0.975).\n    late_time: Relative time after which the planned threshold applies\n        (default 0.9).\n    late_slack: Slack subtracted from ``planned_threshold`` late on\n        (default 0.01).\n\nTranscompiled from: negotiator.boaframework.acceptanceconditions.anac2011.AC_ValueModelAgent", params={}, tags={'acceptance', 'genius', 'gb', 'ai-generated', 'boa', 'genius-translated', 'anac2011'}, extra={}, component_type='acceptance'), 'GACYushu#9f361766': ComponentInfo(key='GACYushu#9f361766', short_name='GACYushu', full_type_name='negmas.gb.components.genius.acceptance.anac2010.GACYushu', cls=<class 'negmas.gb.components.genius.acceptance.anac2010.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={'acceptance', 'genius', 'gb', 'anac2010', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='acceptance'), 'GAgentFSEGAOffering#0948d60f': ComponentInfo(key='GAgentFSEGAOffering#0948d60f', short_name='GAgentFSEGAOffering', full_type_name='negmas.gb.components.genius.offering.anac2010.GAgentFSEGAOffering', cls=<class 'negmas.gb.components.genius.offering.anac2010.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', 'gb', 'anac2010', 'offering', 'ai-generated', 'boa', 'genius-translated', 'adaptive'}, extra={}, component_type='offering'), 'GAgentK2Offering#a2478dd4': ComponentInfo(key='GAgentK2Offering#a2478dd4', short_name='GAgentK2Offering', full_type_name='negmas.gb.components.genius.offering.anac2011.GAgentK2Offering', cls=<class 'negmas.gb.components.genius.offering.anac2011.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', 'gb', 'offering', 'ai-generated', 'boa', 'genius-translated', 'adaptive', 'anac2011'}, extra={}, component_type='offering'), 'GAgentKOffering#78a8fded': ComponentInfo(key='GAgentKOffering#78a8fded', short_name='GAgentKOffering', full_type_name='negmas.gb.components.genius.offering.anac2010.GAgentKOffering', cls=<class 'negmas.gb.components.genius.offering.anac2010.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', 'gb', 'anac2010', 'offering', 'ai-generated', 'boa', 'genius-translated', 'adaptive'}, extra={}, component_type='offering'), 'GAgentLGModel#44fc2095': ComponentInfo(key='GAgentLGModel#44fc2095', short_name='GAgentLGModel', full_type_name='negmas.gb.components.genius.models.agent_specific.GAgentLGModel', cls=<class 'negmas.gb.components.genius.models.agent_specific.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', 'gb', 'learning', 'anac2012', 'model', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='model'), 'GAgentLGOffering#7592dedb': ComponentInfo(key='GAgentLGOffering#7592dedb', short_name='GAgentLGOffering', full_type_name='negmas.gb.components.genius.offering.anac2012.GAgentLGOffering', cls=<class 'negmas.gb.components.genius.offering.anac2012.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', 'gb', 'learning', 'anac2012', 'offering', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='offering'), 'GAgentMROffering#642854c8': ComponentInfo(key='GAgentMROffering#642854c8', short_name='GAgentMROffering', full_type_name='negmas.gb.components.genius.offering.anac2012.GAgentMROffering', cls=<class 'negmas.gb.components.genius.offering.anac2012.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', 'gb', 'risk-based', 'anac2012', 'offering', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='offering'), 'GAgentSmithOffering#3eaa762b': ComponentInfo(key='GAgentSmithOffering#3eaa762b', short_name='GAgentSmithOffering', full_type_name='negmas.gb.components.genius.offering.anac2010.GAgentSmithOffering', cls=<class 'negmas.gb.components.genius.offering.anac2010.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', 'gb', 'anac2010', 'offering', 'ai-generated', 'boa', 'genius-translated', 'time-based'}, extra={}, component_type='offering'), 'GAgentXFrequencyModel#910ab69d': ComponentInfo(key='GAgentXFrequencyModel#910ab69d', short_name='GAgentXFrequencyModel', full_type_name='negmas.gb.components.genius.models.frequency.GAgentXFrequencyModel', cls=<class 'negmas.gb.components.genius.models.frequency.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', 'gb', 'learning', 'frequency', 'model', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='model'), 'GBRAMAgent2Offering#9bf898e3': ComponentInfo(key='GBRAMAgent2Offering#9bf898e3', short_name='GBRAMAgent2Offering', full_type_name='negmas.gb.components.genius.offering.anac2012.GBRAMAgent2Offering', cls=<class 'negmas.gb.components.genius.offering.anac2012.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', 'gb', 'anac2012', 'offering', 'ai-generated', 'boa', 'genius-translated', 'opponent-modeling'}, extra={}, component_type='offering'), 'GBRAMAgentOffering#0928cc23': ComponentInfo(key='GBRAMAgentOffering#0928cc23', short_name='GBRAMAgentOffering', full_type_name='negmas.gb.components.genius.offering.anac2011.GBRAMAgentOffering', cls=<class 'negmas.gb.components.genius.offering.anac2011.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', 'gb', 'anac2011', 'offering', 'ai-generated', 'boa', 'genius-translated', 'opponent-modeling'}, extra={}, component_type='offering'), 'GBayesianModel#9368760d': ComponentInfo(key='GBayesianModel#9368760d', short_name='GBayesianModel', full_type_name='negmas.gb.components.genius.models.bayesian.GBayesianModel', cls=<class 'negmas.gb.components.genius.models.bayesian.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', 'gb', 'learning', 'model', 'ai-generated', 'bayesian', 'boa', 'genius-translated'}, extra={}, component_type='model'), 'GBoulwareOffering#bbf9207c': ComponentInfo(key='GBoulwareOffering#bbf9207c', short_name='GBoulwareOffering', full_type_name='negmas.gb.components.genius.offering.base_offering.GBoulwareOffering', cls=<class 'negmas.gb.components.genius.offering.base_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', 'gb', 'boulware', 'offering', 'ai-generated', 'boa', 'genius-translated', 'time-based'}, extra={}, component_type='offering'), 'GCUHKAgentOffering#aa5c4df6': ComponentInfo(key='GCUHKAgentOffering#aa5c4df6', short_name='GCUHKAgentOffering', full_type_name='negmas.gb.components.genius.offering.anac2012.GCUHKAgentOffering', cls=<class 'negmas.gb.components.genius.offering.anac2012.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', 'gb', 'anac2012', 'offering', 'ai-generated', 'boa', 'genius-translated', 'adaptive'}, extra={}, component_type='offering'), 'GCUHKFrequencyModel#7f49ec36': ComponentInfo(key='GCUHKFrequencyModel#7f49ec36', short_name='GCUHKFrequencyModel', full_type_name='negmas.gb.components.genius.models.frequency.GCUHKFrequencyModel', cls=<class 'negmas.gb.components.genius.models.frequency.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={'learning', 'frequency', 'model', 'genius-translated', 'genius', 'gb', 'anac2012', 'ai-generated', 'boa'}, extra={}, component_type='model'), 'GChoosingAllBids#f80c3428': ComponentInfo(key='GChoosingAllBids#f80c3428', short_name='GChoosingAllBids', full_type_name='negmas.gb.components.genius.offering.base_offering.GChoosingAllBids', cls=<class 'negmas.gb.components.genius.offering.base_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', 'gb', 'offering', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='offering'), 'GConcederOffering#d38a648c': ComponentInfo(key='GConcederOffering#d38a648c', short_name='GConcederOffering', full_type_name='negmas.gb.components.genius.offering.base_offering.GConcederOffering', cls=<class 'negmas.gb.components.genius.offering.base_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', 'gb', 'conceder', 'offering', 'ai-generated', 'boa', 'genius-translated', 'time-based'}, extra={}, component_type='offering'), 'GDefaultModel#bb93d6aa': ComponentInfo(key='GDefaultModel#bb93d6aa', short_name='GDefaultModel', full_type_name='negmas.gb.components.genius.models.baselines.GDefaultModel', cls=<class 'negmas.gb.components.genius.models.baselines.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', 'gb', 'simple', 'model', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='model'), 'GFSEGABayesianModel#c9da9de6': ComponentInfo(key='GFSEGABayesianModel#c9da9de6', short_name='GFSEGABayesianModel', full_type_name='negmas.gb.components.genius.models.bayesian.GFSEGABayesianModel', cls=<class 'negmas.gb.components.genius.models.bayesian.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={'learning', 'anac2010', 'model', 'genius-translated', 'genius', 'gb', 'ai-generated', 'bayesian', 'boa'}, extra={}, component_type='model'), 'GFawkesOffering#35d320aa': ComponentInfo(key='GFawkesOffering#35d320aa', short_name='GFawkesOffering', full_type_name='negmas.gb.components.genius.offering.anac2013.GFawkesOffering', cls=<class 'negmas.gb.components.genius.offering.anac2013.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', 'gb', 'anac2013', 'offering', 'ai-generated', 'boa', 'genius-translated', 'prediction'}, extra={}, component_type='offering'), 'GGahboninhoOffering#12640926': ComponentInfo(key='GGahboninhoOffering#12640926', short_name='GGahboninhoOffering', full_type_name='negmas.gb.components.genius.offering.anac2011.GGahboninhoOffering', cls=<class 'negmas.gb.components.genius.offering.anac2011.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', 'gb', 'offering', 'ai-generated', 'boa', 'genius-translated', 'adaptive', 'anac2011'}, extra={}, component_type='offering'), 'GHardHeadedFrequencyModel#ec446226': ComponentInfo(key='GHardHeadedFrequencyModel#ec446226', short_name='GHardHeadedFrequencyModel', full_type_name='negmas.gb.components.genius.models.frequency.GHardHeadedFrequencyModel', cls=<class 'negmas.gb.components.genius.models.frequency.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', 'gb', 'learning', 'frequency', 'model', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='model'), 'GHardHeadedOffering#2c0a29f9': ComponentInfo(key='GHardHeadedOffering#2c0a29f9', short_name='GHardHeadedOffering', full_type_name='negmas.gb.components.genius.offering.anac2011.GHardHeadedOffering', cls=<class 'negmas.gb.components.genius.offering.anac2011.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={'conservative', 'genius', 'gb', 'offering', 'ai-generated', 'boa', 'genius-translated', 'anac2011'}, extra={}, component_type='offering'), 'GHardlinerOffering#2ec610ce': ComponentInfo(key='GHardlinerOffering#2ec610ce', short_name='GHardlinerOffering', full_type_name='negmas.gb.components.genius.offering.base_offering.GHardlinerOffering', cls=<class 'negmas.gb.components.genius.offering.base_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', 'gb', 'hardliner', 'offering', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='offering'), 'GIAMCrazyHagglerOffering#f87391ae': ComponentInfo(key='GIAMCrazyHagglerOffering#f87391ae', short_name='GIAMCrazyHagglerOffering', full_type_name='negmas.gb.components.genius.offering.anac2010.GIAMCrazyHagglerOffering', cls=<class 'negmas.gb.components.genius.offering.anac2010.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    max_sampling_attempts: Number of random outcomes tried before falling\n        back to an inverter query (default 100).\n    max_utility_bound: Upper bound of the fallback inverter query, i.e. the\n        policy searches ``[breakoff, max_utility_bound]`` (default 1.1).\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2010.IAMCrazyHaggler_Offering", params={}, tags={'genius', 'gb', 'anac2010', 'hardliner', 'offering', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='offering'), 'GIAMHaggler2012Offering#3d5c5026': ComponentInfo(key='GIAMHaggler2012Offering#3d5c5026', short_name='GIAMHaggler2012Offering', full_type_name='negmas.gb.components.genius.offering.anac2012.GIAMHaggler2012Offering', cls=<class 'negmas.gb.components.genius.offering.anac2012.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={'conservative', 'genius', 'gb', 'anac2012', 'offering', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='offering'), 'GIAMhaggler2010Offering#b062a385': ComponentInfo(key='GIAMhaggler2010Offering#b062a385', short_name='GIAMhaggler2010Offering', full_type_name='negmas.gb.components.genius.offering.anac2010.GIAMhaggler2010Offering', cls=<class 'negmas.gb.components.genius.offering.anac2010.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={'conservative', 'genius', 'gb', 'anac2010', 'offering', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='offering'), 'GIAMhaggler2011Offering#a0103931': ComponentInfo(key='GIAMhaggler2011Offering#a0103931', short_name='GIAMhaggler2011Offering', full_type_name='negmas.gb.components.genius.offering.anac2011.GIAMhaggler2011Offering', cls=<class 'negmas.gb.components.genius.offering.anac2011.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={'conservative', 'genius', 'gb', 'offering', 'ai-generated', 'boa', 'genius-translated', 'anac2011'}, extra={}, component_type='offering'), 'GIAMhagglerBayesianModel#706cab28': ComponentInfo(key='GIAMhagglerBayesianModel#706cab28', short_name='GIAMhagglerBayesianModel', full_type_name='negmas.gb.components.genius.models.bayesian.GIAMhagglerBayesianModel', cls=<class 'negmas.gb.components.genius.models.bayesian.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', 'gb', 'learning', 'model', 'ai-generated', 'bayesian', 'boa', 'genius-translated'}, extra={}, component_type='model'), 'GInoxAgentModel#20ff988e': ComponentInfo(key='GInoxAgentModel#20ff988e', short_name='GInoxAgentModel', full_type_name='negmas.gb.components.genius.models.agent_specific.GInoxAgentModel', cls=<class 'negmas.gb.components.genius.models.agent_specific.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', 'gb', 'learning', 'anac2013', 'model', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='model'), 'GInoxAgentOffering#07658ce9': ComponentInfo(key='GInoxAgentOffering#07658ce9', short_name='GInoxAgentOffering', full_type_name='negmas.gb.components.genius.offering.anac2013.GInoxAgentOffering', cls=<class 'negmas.gb.components.genius.offering.anac2013.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', 'gb', 'anac2013', 'offering', 'ai-generated', 'boa', 'genius-translated', 'adaptive'}, extra={}, component_type='offering'), 'GLinearOffering#b6cb7e16': ComponentInfo(key='GLinearOffering#b6cb7e16', short_name='GLinearOffering', full_type_name='negmas.gb.components.genius.offering.base_offering.GLinearOffering', cls=<class 'negmas.gb.components.genius.offering.base_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', 'gb', 'offering', 'ai-generated', 'linear', 'boa', 'genius-translated', 'time-based'}, extra={}, component_type='offering'), 'GNashFrequencyModel#9ac46b74': ComponentInfo(key='GNashFrequencyModel#9ac46b74', short_name='GNashFrequencyModel', full_type_name='negmas.gb.components.genius.models.frequency.GNashFrequencyModel', cls=<class 'negmas.gb.components.genius.models.frequency.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={'learning', 'frequency', 'model', 'genius-translated', 'genius', 'gb', 'ai-generated', 'boa', 'nash'}, extra={}, component_type='model'), 'GNiceTitForTatOffering#409b1df5': ComponentInfo(key='GNiceTitForTatOffering#409b1df5', short_name='GNiceTitForTatOffering', full_type_name='negmas.gb.components.genius.offering.anac2011.GNiceTitForTatOffering', cls=<class 'negmas.gb.components.genius.offering.anac2011.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={'genius', 'gb', 'offering', 'ai-generated', 'tit-for-tat', 'boa', 'genius-translated', 'anac2011'}, extra={}, component_type='offering'), 'GNozomiOffering#c0645336': ComponentInfo(key='GNozomiOffering#c0645336', short_name='GNozomiOffering', full_type_name='negmas.gb.components.genius.offering.anac2010.GNozomiOffering', cls=<class 'negmas.gb.components.genius.offering.anac2010.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', 'gb', 'anac2010', 'offering', 'ai-generated', 'boa', 'genius-translated', 'adaptive'}, extra={}, component_type='offering'), 'GOMACagentOffering#36874e4d': ComponentInfo(key='GOMACagentOffering#36874e4d', short_name='GOMACagentOffering', full_type_name='negmas.gb.components.genius.offering.anac2012.GOMACagentOffering', cls=<class 'negmas.gb.components.genius.offering.anac2012.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    discount_threshold: Discount below which the low-discount target curve is\n        used instead of the normal one (default 0.845).\n    e_high_discount: Concession exponent parameter used when the discount is\n        at or above ``discount_threshold`` (default 0.033).\n    e_low_discount: Concession exponent parameter used below that threshold\n        (default 0.04).\n    discount_power: Exponent applied to the discount when deriving the upper\n        target bound in the low-discount branch (default 0.2).\n    min_utility_margin: Multiplier applied to ``min_utility`` for the lower\n        target bound in the low-discount branch (default 1.05).\n    opening_time: Relative time before which the best outcome is offered\n        unconditionally (default 0.02).\n    narrow_band: Fractional half-width of the first (narrow) utility band\n        searched around the target, i.e. ``[target * (1 - narrow_band),\n        target * (1 + narrow_band)]`` (default 0.01).\n    wide_band_tolerance: Absolute slack used for the fallback (wider) band\n        search when the narrow band is empty (default 0.05).\n\nTranscompiled from: negotiator.boaframework.offeringstrategy.anac2012.OMACagent_Offering', params={}, tags={'genius', 'gb', 'anac2012', 'offering', 'ai-generated', 'boa', 'genius-translated', 'prediction'}, extra={}, component_type='offering'), 'GOppositeModel#01b759dd': ComponentInfo(key='GOppositeModel#01b759dd', short_name='GOppositeModel', full_type_name='negmas.gb.components.genius.models.baselines.GOppositeModel', cls=<class 'negmas.gb.components.genius.models.baselines.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', 'gb', 'simple', 'model', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='model'), 'GPerfectModel#144e3d90': ComponentInfo(key='GPerfectModel#144e3d90', short_name='GPerfectModel', full_type_name='negmas.gb.components.genius.models.baselines.GPerfectModel', cls=<class 'negmas.gb.components.genius.models.baselines.GPerfectModel'>, source='negmas', description="Perfect (oracle) opponent model — has access to the opponent's true ufun.\n\nThis is the Genius ``PerfectModel``: an oracle for testing/analysis where\nthe opponent's preferences are known. Pass the opponent's true\n`BaseUtilityFunction` as ``ufun`` (at construction or later,\n``model.ufun = ...``); ``eval`` / ``eval_normalized`` then delegate to it.\nWhen no ``ufun`` is set it falls back to ``0.5`` (uniform).\n\nImplemented as a thin alias of `PeekingOpponentModel` (the working oracle in\n``gb.components.models.ufun``) so the two share one code path; the only\naddition is the multilateral per-partner ``private_info`` update inherited\nfrom the Genius model family.\n\nTranscompiled from: negotiator.boaframework.opponentmodel.PerfectModel", params={}, tags={'genius', 'gb', 'testing', 'oracle', 'model', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='model'), 'GRandomOffering#d28c9e2c': ComponentInfo(key='GRandomOffering#d28c9e2c', short_name='GRandomOffering', full_type_name='negmas.gb.components.genius.offering.base_offering.GRandomOffering', cls=<class 'negmas.gb.components.genius.offering.base_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', 'gb', 'random', 'offering', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='offering'), 'GScalableBayesianModel#b39e734c': ComponentInfo(key='GScalableBayesianModel#b39e734c', short_name='GScalableBayesianModel', full_type_name='negmas.gb.components.genius.models.bayesian.GScalableBayesianModel', cls=<class 'negmas.gb.components.genius.models.bayesian.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={'learning', 'model', 'genius-translated', 'scalable', 'genius', 'gb', 'ai-generated', 'bayesian', 'boa'}, extra={}, component_type='model'), 'GSmithFrequencyModel#10d3731d': ComponentInfo(key='GSmithFrequencyModel#10d3731d', short_name='GSmithFrequencyModel', full_type_name='negmas.gb.components.genius.models.frequency.GSmithFrequencyModel', cls=<class 'negmas.gb.components.genius.models.frequency.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', 'gb', 'learning', 'frequency', 'model', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='model'), 'GTheFawkesModel#cdae2e51': ComponentInfo(key='GTheFawkesModel#cdae2e51', short_name='GTheFawkesModel', full_type_name='negmas.gb.components.genius.models.agent_specific.GTheFawkesModel', cls=<class 'negmas.gb.components.genius.models.agent_specific.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', 'gb', 'learning', 'anac2013', 'model', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='model'), 'GTheNegotiatorOffering#cf8bbc1d': ComponentInfo(key='GTheNegotiatorOffering#cf8bbc1d', short_name='GTheNegotiatorOffering', full_type_name='negmas.gb.components.genius.offering.anac2011.GTheNegotiatorOffering', cls=<class 'negmas.gb.components.genius.offering.anac2011.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', 'gb', 'piecewise', 'offering', 'ai-generated', 'boa', 'genius-translated', 'anac2011'}, extra={}, component_type='offering'), 'GTheNegotiatorReloadedOffering#5c7c56c6': ComponentInfo(key='GTheNegotiatorReloadedOffering#5c7c56c6', short_name='GTheNegotiatorReloadedOffering', full_type_name='negmas.gb.components.genius.offering.anac2012.GTheNegotiatorReloadedOffering', cls=<class 'negmas.gb.components.genius.offering.anac2012.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', 'gb', 'anac2012', 'piecewise', 'offering', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='offering'), 'GTimeDependentOffering#90984829': ComponentInfo(key='GTimeDependentOffering#90984829', short_name='GTimeDependentOffering', full_type_name='negmas.gb.components.genius.offering.base_offering.GTimeDependentOffering', cls=<class 'negmas.gb.components.genius.offering.base_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', 'gb', 'offering', 'ai-generated', 'boa', 'genius-translated', 'time-based'}, extra={}, component_type='offering'), 'GUniformModel#1753c3ba': ComponentInfo(key='GUniformModel#1753c3ba', short_name='GUniformModel', full_type_name='negmas.gb.components.genius.models.baselines.GUniformModel', cls=<class 'negmas.gb.components.genius.models.baselines.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', 'gb', 'simple', 'model', 'ai-generated', 'boa', 'genius-translated'}, extra={}, component_type='model'), 'GValueModelAgentOffering#4628548a': ComponentInfo(key='GValueModelAgentOffering#4628548a', short_name='GValueModelAgentOffering', full_type_name='negmas.gb.components.genius.offering.anac2011.GValueModelAgentOffering', cls=<class 'negmas.gb.components.genius.offering.anac2011.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', 'gb', 'offering', 'ai-generated', 'boa', 'genius-translated', 'value-modeling', 'anac2011'}, extra={}, component_type='offering'), 'GWorstModel#be6a4ef2': ComponentInfo(key='GWorstModel#be6a4ef2', short_name='GWorstModel', full_type_name='negmas.gb.components.genius.models.baselines.GWorstModel', cls=<class 'negmas.gb.components.genius.models.baselines.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', 'gb', 'simple', 'model', 'ai-generated', 'boa', 'genius-translated', 'pessimistic'}, extra={}, component_type='model'), 'GYushuOffering#df5d83e2': ComponentInfo(key='GYushuOffering#df5d83e2', short_name='GYushuOffering', full_type_name='negmas.gb.components.genius.offering.anac2010.GYushuOffering', cls=<class 'negmas.gb.components.genius.offering.anac2010.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', 'gb', 'anac2010', 'offering', 'ai-generated', 'boa', 'genius-translated', 'sigmoid'}, extra={}, component_type='offering'), 'HybridOfferingPolicy#f847810e': ComponentInfo(key='HybridOfferingPolicy#f847810e', short_name='HybridOfferingPolicy', full_type_name='negmas.gb.components.offering.HybridOfferingPolicy', cls=<class 'negmas.gb.components.offering.HybridOfferingPolicy'>, source='negmas', description="HybridOffering policy implementation.\n\nCombines a time-based (quadratic Bezier) concession curve with a\nbehaviour-based reaction to the opponent's concessions.\n\nArgs:\n    initial_utility: Bezier control point at ``t=0``. ``NaN`` (default)\n        means *auto*: use ``auto_initial_utility``.\n    concession_ratio: Middle Bezier control point. ``NaN`` (default) means\n        *auto*: use ``auto_concession_ratio``.\n    final_utility: Bezier control point at ``t=1``. ``NaN`` (default) means\n        *auto*: derive it from the domain size using\n        ``final_utility_ladder`` / ``final_utility_floor``. Whether given\n        or derived, it is always floored at the reserved value.\n    empathy_score: How strongly the opponent's concession moves our target\n        in `behaviour_based`. ``NaN`` (default) means *auto*: use\n        ``auto_empathy_score``.\n    auto_initial_utility: Value used for ``initial_utility`` in auto mode.\n    auto_concession_ratio: Value used for ``concession_ratio`` in auto mode.\n    auto_empathy_score: Value used for ``empathy_score`` in auto mode.\n    domain_size_cap: Domain cardinality is clipped to this before consulting\n        ``final_utility_ladder``.\n    final_utility_ladder: Ordered ``(max_domain_size, final_utility)`` pairs.\n        The first pair whose ``max_domain_size`` exceeds the (clipped) domain\n        size supplies ``final_utility`` in auto mode.\n    final_utility_floor: ``final_utility`` used in auto mode when the domain\n        is larger than every threshold in ``final_utility_ladder``.\n    behavior_min_offers: Minimum number of offers received before the\n        behaviour-based component is mixed in (pure time-based before that).\n    enumeration_levels: ``levels`` used to discretize a continuous outcome\n        space when enumerating candidate outcomes.\n    enumeration_max_cardinality: ``max_cardinality`` used when enumerating a\n        continuous outcome space.\n    frac_time_based: Window weights (keyed by window length) applied to the\n        opponent's recent utility differences in `behaviour_based`.\n    above_only: Only consider outcomes at or above the target utility.", params={}, tags={'offering', 'builtin', 'hybrid', 'sao'}, extra={}, component_type='offering'), 'KDEWeightUFunModel#6a66ccfe': ComponentInfo(key='KDEWeightUFunModel#6a66ccfe', short_name='KDEWeightUFunModel', full_type_name='negmas.gb.components.models.weights.KDEWeightUFunModel', cls=<class 'negmas.gb.components.models.weights.KDEWeightUFunModel'>, source='negmas', description='Issue weights via kernel density estimation — Coehoorn & Jennings [50].\n\nThe most-established issue-weight method in the survey (§5.3.1). For each\nissue it collects the sequence of normalized distances between sequential\noffers and fits a Gaussian kernel density estimate (`scipy.stats.gaussian_kde`)\nto that distance distribution. An issue whose distances concentrate near zero\n(the opponent barely moves it) is important, so the issue weight is the KDE\nprobability mass in ``[0, threshold]`` — i.e. ``P(distance <= threshold)`` —\nthen normalized across issues. Per-issue value utilities are estimated from\noffer frequency.\n\nArgs:\n    threshold: The distance below which a move counts as "held" when\n        integrating the KDE (a fraction of the normalized ``[0, 1]`` range).\n\nRemarks:\n    - The survey\'s full method maps distance to weight using a database of\n      previous negotiations; this is a domain-agnostic *online* rendition\n      that estimates the distance distribution from the running negotiation.\n    - Falls back to the mean-distance estimate ``1 - mean_distance`` per issue\n      until there are enough distinct distance samples to fit a KDE.\n    - Returns utilities already normalized to ``[0, 1]``.\n\n*AI Generated (Coehoorn & Jennings KDE issue weights).*', params={}, tags={'learning', 'issue-weights', 'model', 'linear', 'kde', 'builtin', 'survey', 'sao'}, extra={}, component_type='model'), 'LuceProfileClassifierModel#09ee9a95': ComponentInfo(key='LuceProfileClassifierModel#09ee9a95', short_name='LuceProfileClassifierModel', full_type_name='negmas.gb.components.models.classifier.LuceProfileClassifierModel', cls=<class 'negmas.gb.components.models.classifier.LuceProfileClassifierModel'>, source='negmas', description="Classifies the opponent among candidate profiles via Luce numbers.\n\nThe model is given a finite set of candidate opponent utility functions\n(``profiles``). Following Lin et al. [123,124], a rational opponent using\nprofile ``t`` is assumed to offer outcome ``o`` with probability proportional\nto its *Luce number* ``L_t(o) = u_t(o) / Σ_{o'} u_t(o')`` — the outcome's\nutility divided by the sum of utilities over the outcome space. Each observed\nopponent offer therefore updates a Bayesian posterior over the candidate\nprofiles (accumulated in log-space for numerical stability).\n\nThe estimated opponent utility of an outcome is the posterior-weighted average\nof the candidate utilities (or, if ``use_map`` is set, the utility under the\nsingle most-probable profile — the choice the survey describes).\n\nArgs:\n    profiles: The candidate opponent utility functions to classify among.\n    use_map: If ``True``, evaluate using only the maximum-a-posteriori\n        profile; otherwise use the posterior-weighted average of all profiles.\n    max_outcomes: Cap on the number of outcomes sampled to compute the Luce\n        denominators (for large/continuous spaces).\n\nRemarks:\n    - The Luce denominators and combination use each candidate's *normalized*\n      utility (``eval_normalized``), so utilities are non-negative and\n      comparable across profiles.\n    - Before any offer is observed the posterior is uniform, so ``eval``\n      returns the plain average of the candidate utilities.\n\n*AI Generated (Lin et al. Luce-number classifier).*", params={}, tags={'learning', 'classification', 'model', 'bayesian', 'builtin', 'survey', 'sao'}, extra={}, component_type='model'), 'MarkovChainOfferingModel#1eb5a7f8': ComponentInfo(key='MarkovChainOfferingModel#1eb5a7f8', short_name='MarkovChainOfferingModel', full_type_name='negmas.models.strategy.MarkovChainOfferingModel', cls=<class 'negmas.models.strategy.MarkovChainOfferingModel'>, source='negmas', description="Forecasts the opponent's offers with a Markov chain over concession states.\n\nA time-series-forecasting offering-strategy model (survey §5.4.2) following\nNarayanan & Jennings [140]. The opponent's utility is discretized into\n``n_states`` bins; the observed sequence of states estimates a (Laplace-smoothed)\ntransition matrix. The chain is then rolled forward from the current state to\nforecast the expected utility of a future offer.\n\nArgs:\n    n_states: Number of discrete utility states (bins over ``[0, 1]``).\n    alpha: Laplace-smoothing pseudo-count added to every transition.\n\n*AI Generated (Narayanan & Jennings Markov-chain offer forecaster).*", params={}, tags={'markov-chain', 'time-series', 'offering-model', 'builtin', 'survey'}, extra={}, component_type='offering-model'), 'MiCROAcceptancePolicy#d9b48a8a': ComponentInfo(key='MiCROAcceptancePolicy#d9b48a8a', short_name='MiCROAcceptancePolicy', full_type_name='negmas.gb.components.acceptance.MiCROAcceptancePolicy', cls=<class 'negmas.gb.components.acceptance.MiCROAcceptancePolicy'>, 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={'acceptance', 'builtin', 'micro', 'sao'}, extra={}, component_type='acceptance'), 'MiCROOfferingPolicy#0e4aac7e': ComponentInfo(key='MiCROOfferingPolicy#0e4aac7e', short_name='MiCROOfferingPolicy', full_type_name='negmas.gb.components.offering.MiCROOfferingPolicy', cls=<class 'negmas.gb.components.offering.MiCROOfferingPolicy'>, source='negmas', description='MiCROOffering policy implementation.', params={}, tags={'offering', 'builtin', 'micro', 'sao'}, extra={}, component_type='offering'), 'NiceTitForTatOfferingPolicy#d30bd425': ComponentInfo(key='NiceTitForTatOfferingPolicy#d30bd425', short_name='NiceTitForTatOfferingPolicy', full_type_name='negmas.gb.components.offering.NiceTitForTatOfferingPolicy', cls=<class 'negmas.gb.components.offering.NiceTitForTatOfferingPolicy'>, source='negmas', description='The bidding (offering) strategy of the Nice Tit for Tat agent\n(Baarslag, Hindriks & Jonker, 2013, "A Tit for Tat Negotiation Strategy\nfor Real-Time Bilateral Negotiations").\n\nThe strategy reciprocates in the agent\'s *own* utility (the opponent\'s\nutility is unknown and any model of it is unreliable, so we measure the\nopponent\'s concession as the change in *our* utility of the opponent\'s\nsuccessive offers) and aims for a bargaining solution point of the\nscenario rather than naively mirroring the opponent\'s raw concession\n(naive mirroring settles for ~0.5 utility and misses win-win deals).\nBy default the target is the Nash bargaining point (as in the paper);\nother solution concepts can be selected with ``target`` (see below):\n\nThis follows the algorithm of the reference Genius implementation\n(Baarslag\'s ``NiceTitForTat``), working entirely in the agent\'s *normalized*\n``[0, 1]`` utility:\n\n1. **Cooperate first.** Initially the agent offers its best outcome\n   (it never defects first).\n2. **Estimate ``my_nash``.** Using the opponent model\n   (``negotiator.opponent_ufun``) and the calculators in\n   `negmas.preferences.ops`, estimate the chosen bargaining solution and take\n   the agent\'s own utility ``p_me`` at it. Scale it by a multiplier that\n   depends on how far the opponent started from the agent\n   (``1.4 - 0.6 * initial_gap``) and floor it: for the Nash target at\n   ``nash_min`` (``0.5`` by default, as in the reference); for other targets\n   only at the reserved value.\n3. **Reciprocate the opponent\'s observed concession.** Measure the\n   opponent\'s concession *in the agent\'s own utility* as\n   ``max_offered_to_me - first_offered_to_me`` (how far the best bid it has\n   offered us has moved from its starting bid — directly observed, not\n   model-estimated) and express it as a fraction of the way to ``my_nash``.\n   The agent concedes the same fraction of its own gap from ``1`` down to\n   ``my_nash``: ``target = 1 - factor * (1 - my_nash)``. Then a **concession\n   bonus** (a small constant baseline from the discount factor plus a ramp\n   near the deadline) pulls the target the rest of the way toward ``my_nash``\n   — this is what lets a mirror match concede and agree instead of\n   deadlocking at maximum utility.\n4. **Make the offer attractive to the opponent.** Among the outcomes in the\n   agent\'s acceptable utility band ``[target, 1]``, pick the one the\n   opponent model rates highest — the trade-off query\n   ``argmax_{u_me >= target} u_opp``, answered by a `ParetoSampler`\n   (``pareto_sampler_type``) built on the normalized agent ufun with the\n   opponent model as the opponent ufun (via ``ufun.make_pareto_sampler``,\n   cached and re-initialized as the same model instance learns). If the\n   sampler cannot answer (no result, or its additivity requirements are not\n   met), the policy falls back to inverting the normalized ufun over the\n   band. Finally, if the best bid the opponent has already offered us is\n   worth at least as much to us as our planned bid, we offer *that* bid\n   instead (the reference\'s ``makeAppropriate``), so consensus forms as soon\n   as the opponent\'s standing offer beats our plan.\n\nThe opponent model is accessed through ``self.negotiator.opponent_ufun``\n(a `UFunModel`), which may be provided to the negotiator or left to a\ndefault (see `NiceTitForTatNegotiator`).\n\n*AI Generated (implementation of the Baarslag 2013 Nice Tit for Tat bidding\nstrategy for negmas).*\n\nArgs:\n    sample_size: Maximum number of outcomes to sample from the utility band\n        when selecting the opponent-attractive offer.\n    max_cardinality: Maximum number of outcomes to enumerate/sample when\n        estimating the bargaining point.\n    nash_refresh: Re-estimate the bargaining point every this many rounds\n        (1 = every round, reflecting an opponent model that keeps\n        learning).\n    stochastic: If ``True`` and no opponent model is available, pick a\n        random in-band outcome instead of the worst-in-band one.\n    target: The bargaining solution to aim for. One of ``"nash"`` (default,\n        Nash bargaining), ``"kalai"`` (Kalai egalitarian),\n        ``"kalai_smorodinsky"`` / ``"ks"`` (Kalai-Smorodinsky),\n        ``"max_welfare"`` (utilitarian / max sum of utilities), or\n        ``"max_relative_welfare"`` (max sum of relative gains). Selected via\n        the corresponding calculator in `negmas.preferences.ops`.\n    nash_min: Lower clamp on the estimated ``my_nash`` target utility, applied\n        **only** for the ``"nash"`` target (the reference agent never asks for\n        less than ``0.5``). For other solution concepts the target is floored\n        at the reserved value instead, so a legitimately lower ``p_me`` is not\n        inflated.\n    pareto_sampler_type: The `ParetoSampler` implementation used for step iv\n        (the opponent-attractive trade-off query). Defaults to\n        `DefaultParetoSampler` (``AdaptiveParetoSampler``), which uses the\n        exact `BruteForceParetoSampler` on small outcome spaces and a\n        scalable backend on large ones. Pass a specific sampler type (e.g.\n        `BruteForceParetoSampler`, or `IPSParetoSampler` for very large\n        additive domains) to override. The sampler is queried each round via\n        ``best_for_opponent`` with the opponent model as the opponent ufun;\n        if it cannot answer the query the policy falls back to the inverter\n        path.\n\nRemarks:\n    - Requires the negotiator to expose ``opponent_ufun`` (a `UFunModel`\n      or ``None``). When it is ``None`` the policy degrades to naive\n      tit-for-tat.', params={}, tags={'offering', 'tit-for-tat', 'nash', 'builtin', 'opponent-modeling', 'sao'}, extra={}, component_type='offering'), 'NoneOfferingPolicy#0a617c30': ComponentInfo(key='NoneOfferingPolicy#0a617c30', 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={'offering', 'simple', 'builtin', 'sao'}, extra={}, component_type='offering'), 'OfferBest#15bf9809': ComponentInfo(key='OfferBest#15bf9809', 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={'optimal', 'builtin', 'offering', 'sao'}, extra={}, component_type='offering'), 'OfferTop#8c983938': ComponentInfo(key='OfferTop#8c983938', 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={'optimal', 'builtin', 'offering', 'sao'}, extra={}, component_type='offering'), 'PeekingOpponentModel#855a3613': ComponentInfo(key='PeekingOpponentModel#855a3613', short_name='PeekingOpponentModel', full_type_name='negmas.gb.components.models.ufun.PeekingOpponentModel', cls=<class 'negmas.gb.components.models.ufun.PeekingOpponentModel'>, source='negmas', description='An *oracle* opponent model that wraps the opponent\'s true utility function.\n\nIntended for testing/analysis: the model "peeks" at the opponent\'s actual\n`BaseUtilityFunction` and delegates ``eval`` / ``eval_normalized`` to it.\nThis lets a Nice Tit for Tat agent (or any consumer of ``opponent_model``)\nbe tested against a *correct* opponent model, so its concession/Nash-aiming\nbehaviour can be checked without the noise of a learned model.\n\nArgs:\n    ufun: The opponent\'s true utility function. May be set at construction\n        or assigned later (``model.ufun = ...``) before the negotiation\n        starts.\n\nRemarks:\n    - Unlike `FrequencyLinearUFunModel` / `FrequencyUFunModel`, this model\n      does not learn; it simply reads the opponent\'s true utility. Use it\n      only in tests/simulation where the opponent\'s ufun is known.\n\n*AI Generated (oracle opponent model for testing).*', params={}, tags={'testing', 'model', 'oracle', 'builtin', 'sao'}, extra={}, component_type='model'), 'PolynomialOfferingModel#a110ed14': ComponentInfo(key='PolynomialOfferingModel#a110ed14', short_name='PolynomialOfferingModel', full_type_name='negmas.models.strategy.PolynomialOfferingModel', cls=<class 'negmas.models.strategy.PolynomialOfferingModel'>, source='negmas', description="Forecasts the opponent's concession curve by polynomial regression.\n\nA regression-analysis offering-strategy model (survey §5.4.1). It fits a\npolynomial of a given ``degree`` to the ``(relative_time, opponent_utility)``\ntrace (least squares) and evaluates it at the queried time. This is the\npolynomial-interpolation estimator compared by Papaioannou et al. [151,153]\n(they also evaluate cubic splines and a genetic-algorithm fit).\n\nArgs:\n    degree: Degree of the fitted polynomial (``3`` ≈ the cubic used in the\n        survey). The effective degree is capped at ``n_observations - 1``.\n    min_observations: Minimum observations before regression is used; below it\n        :meth:`predict_utility` falls back to the last observed utility.\n        Defaults to ``degree + 1``.\n\n*AI Generated (Papaioannou et al. polynomial offer forecaster).*", params={}, tags={'regression', 'polynomial', 'offering-model', 'builtin', 'survey'}, extra={}, component_type='offering-model'), 'RandomAcceptancePolicy#7e1fd4e4': ComponentInfo(key='RandomAcceptancePolicy#7e1fd4e4', 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={'acceptance', 'random', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'RandomOfferingPolicy#f370c936': ComponentInfo(key='RandomOfferingPolicy#f370c936', 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={'offering', 'random', 'builtin', 'sao'}, extra={}, component_type='offering'), 'RejectAlways#03ffe605': ComponentInfo(key='RejectAlways#03ffe605', 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={'acceptance', 'simple', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'TFTAcceptancePolicy#7fa01ae9': ComponentInfo(key='TFTAcceptancePolicy#7fa01ae9', short_name='TFTAcceptancePolicy', full_type_name='negmas.gb.components.acceptance.TFTAcceptancePolicy', cls=<class 'negmas.gb.components.acceptance.TFTAcceptancePolicy'>, source='negmas', description='An acceptance strategy that concedes as much as the partner (or more)', params={}, tags={'tit-for-tat', 'acceptance', 'builtin', 'sao'}, extra={}, component_type='acceptance'), 'TFTOfferingPolicy#550e7efe': ComponentInfo(key='TFTOfferingPolicy#550e7efe', short_name='TFTOfferingPolicy', full_type_name='negmas.gb.components.offering.TFTOfferingPolicy', cls=<class 'negmas.gb.components.offering.TFTOfferingPolicy'>, source='negmas', description='An acceptance strategy that concedes as much as the partner (or more)', params={}, tags={'tit-for-tat', 'offering', 'builtin', 'sao'}, extra={}, component_type='offering'), 'TimeBasedOfferingPolicy#00fbe254': ComponentInfo(key='TimeBasedOfferingPolicy#00fbe254', 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={'time-based', 'builtin', 'offering', 'sao'}, extra={}, component_type='offering'), 'TimeSeriesOfferingModel#0d7dbd9a': ComponentInfo(key='TimeSeriesOfferingModel#0d7dbd9a', short_name='TimeSeriesOfferingModel', full_type_name='negmas.models.strategy.TimeSeriesOfferingModel', cls=<class 'negmas.models.strategy.TimeSeriesOfferingModel'>, source='negmas', description="Forecasts the opponent's concession curve via Gaussian-process regression.\n\nThis is a time-series-forecasting offering-strategy model (survey §5.4). It fits a\nregressor of *utility-of-opponent-offer* against *relative time* and uses it to\nforecast how the opponent will offer in the future. It re-uses\n:class:`~negmas.models.future.FutureUtilityRegressor` (a Gaussian-process regressor)\nrather than reinventing the regression machinery.", params={}, tags={'regression', 'gaussian-process', 'offering-model', 'builtin', 'survey'}, extra={}, component_type='offering-model'), 'ValueDifferenceUFunModel#5512bd7c': ComponentInfo(key='ValueDifferenceUFunModel#5512bd7c', short_name='ValueDifferenceUFunModel', full_type_name='negmas.gb.components.models.weights.ValueDifferenceUFunModel', cls=<class 'negmas.gb.components.models.weights.ValueDifferenceUFunModel'>, source='negmas', description="Issue weights from value-difference magnitudes — Carbonneau & Vahidov [37].\n\nUnlike `ConcessionRatioUFunModel`, which only counts *whether* an issue's\nvalue changed, this model uses the *magnitude* of the change between two\nsequential offers, normalized by the issue's range (survey §5.3.1). For a\nnumeric issue the per-step difference is ``|v_t - v_{t-1}| / range_i``; for a\ncategorical issue it is a ``0/1`` indicator. The running mean normalized\ndifference ``d_i`` gives the issue weight ``w_i = 1 - d_i`` (then normalized).\nPer-issue value utilities are estimated from offer frequency.\n\nRemarks:\n    - Larger (normalized) moves on an issue ⇒ more concession ⇒ lower weight.\n    - Returns utilities already normalized to ``[0, 1]``; a neutral ``0.5``\n      before any offer is observed.\n\n*AI Generated (Carbonneau & Vahidov value-difference issue weights).*", params={}, tags={'learning', 'issue-weights', 'model', 'linear', 'builtin', 'survey', 'sao'}, extra={}, component_type='model'), 'WAROfferingPolicy#09851aba': ComponentInfo(key='WAROfferingPolicy#09851aba', short_name='WAROfferingPolicy', full_type_name='negmas.gb.components.offering.WAROfferingPolicy', cls=<class 'negmas.gb.components.offering.WAROfferingPolicy'>, source='negmas', description='WAROffering policy implementation.', params={}, tags={'offering', 'builtin', 'rational', 'sao'}, extra={}, component_type='offering'), 'ZeroSumModel#a28a843d': ComponentInfo(key='ZeroSumModel#a28a843d', short_name='ZeroSumModel', full_type_name='negmas.gb.components.models.ufun.ZeroSumModel', cls=<class 'negmas.gb.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={'model', 'builtin', 'zero-sum', 'sao'}, 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#5cd5dc5f': MechanismInfo(key='HillClimbingSTMechanism#5cd5dc5f', 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={'st', 'builtin', 'requires-deadline'}, extra={}), 'ParallelGBMechanism#d4336025': MechanismInfo(key='ParallelGBMechanism#d4336025', 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={'gb', 'propose', 'respond', 'builtin', 'requires-deadline'}, extra={}), 'SAOMechanism#e090b048': MechanismInfo(key='SAOMechanism#e090b048', 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={'propose', 'respond', 'builtin', 'requires-deadline', 'sao'}, extra={}), 'SerialGBMechanism#c7090a61': MechanismInfo(key='SerialGBMechanism#c7090a61', 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={'gb', 'propose', 'respond', 'builtin', 'requires-deadline'}, extra={}), 'SerialTAUMechanism#4db4ebf2': MechanismInfo(key='SerialTAUMechanism#4db4ebf2', 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={'tau', 'gb', 'propose', 'respond', 'builtin'}, extra={}), 'TAUMechanism#1cc9d509': MechanismInfo(key='TAUMechanism#1cc9d509', 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={'tau', 'gb', 'propose', 'respond', 'builtin'}, extra={}), 'VetoSTMechanism#28f5eb30': MechanismInfo(key='VetoSTMechanism#28f5eb30', 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={'st', 'builtin', 'requires-deadline'}, extra={})}

The gloabal mechanism registry.

negmas.registry.negotiator_registry: Registry[NegotiatorInfo] = {'ABMPAgent2#7e2d1bf3': NegotiatorInfo(key='ABMPAgent2#7e2d1bf3', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'AI2014Group2#a85e7e88': NegotiatorInfo(key='AI2014Group2#a85e7e88', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'AdditiveFirstFollowingTBNegotiator#d9cadc7e': NegotiatorInfo(key='AdditiveFirstFollowingTBNegotiator#d9cadc7e', short_name='AdditiveFirstFollowingTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.AdditiveFirstFollowingTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.AdditiveFirstFollowingTBNegotiator'>, source='negmas', description='A time-based negotiator that selectes outcomes from the list allowed by\nthe  current utility level based on a weighted sum of their normalized\nutilities and distances to previous offers', params={}, tags={'propose', 'respond', 'time-based', 'builtin', 'following', 'sao'}, extra={}), 'AdditiveLastOfferFollowingTBNegotiator#2b11cf58': NegotiatorInfo(key='AdditiveLastOfferFollowingTBNegotiator#2b11cf58', short_name='AdditiveLastOfferFollowingTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.AdditiveLastOfferFollowingTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.AdditiveLastOfferFollowingTBNegotiator'>, source='negmas', description='A time-based negotiator that selectes outcomes from the list allowed by\nthe  current utility level based on a weighted sum of their normalized\nutilities and distances to previous offers', params={}, tags={'propose', 'respond', 'time-based', 'builtin', 'following', 'sao'}, extra={}), 'AdditiveParetoFollowingTBNegotiator#721dd286': NegotiatorInfo(key='AdditiveParetoFollowingTBNegotiator#721dd286', short_name='AdditiveParetoFollowingTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.AdditiveParetoFollowingTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.AdditiveParetoFollowingTBNegotiator'>, source='negmas', description='A time-based negotiator that selectes outcomes from the list allowed by\nthe  current utility level based on a weighted sum of their normalized\nutilities and distances to previous offers', params={}, tags={'propose', 'respond', 'time-based', 'builtin', 'following', 'sao'}, extra={}), 'Agent33#fb9f8305': NegotiatorInfo(key='Agent33#fb9f8305', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'Agent36#d2fe2374': NegotiatorInfo(key='Agent36#d2fe2374', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'AgentBuyog#866fee9d': NegotiatorInfo(key='AgentBuyog#866fee9d', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'AgentF#bf732464': NegotiatorInfo(key='AgentF#bf732464', 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', 'anac', 'propose', 'respond'}, extra={}), 'AgentFSEGA#d8696cde': NegotiatorInfo(key='AgentFSEGA#d8696cde', 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', 'propose', 'respond', 'anac-2010'}, extra={}), 'AgentGG#fcde8b55': NegotiatorInfo(key='AgentGG#fcde8b55', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'AgentGP#9f8dc9b2': NegotiatorInfo(key='AgentGP#9f8dc9b2', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'AgentH#54ddab04': NegotiatorInfo(key='AgentH#54ddab04', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'AgentHP#e050c39b': NegotiatorInfo(key='AgentHP#e050c39b', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'AgentHP2#ab17c8c8': NegotiatorInfo(key='AgentHP2#ab17c8c8', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'AgentHerb#dc25d4fd': NegotiatorInfo(key='AgentHerb#dc25d4fd', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'AgentI#f84ab054': NegotiatorInfo(key='AgentI#f84ab054', 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', 'anac-2013', 'anac', 'propose', 'respond'}, extra={}), 'AgentK#1d1caf4a': NegotiatorInfo(key='AgentK#1d1caf4a', 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', 'propose', 'respond', 'anac-2010'}, extra={}), 'AgentK2#ed5318b4': NegotiatorInfo(key='AgentK2#ed5318b4', 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', 'anac', 'anac-2011', 'propose', 'respond'}, extra={}), 'AgentKF#a3ad653f': NegotiatorInfo(key='AgentKF#a3ad653f', 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', 'anac-2013', 'anac', 'propose', 'respond'}, extra={}), 'AgentKN#fe2f8b38': NegotiatorInfo(key='AgentKN#fe2f8b38', 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', 'anac', 'propose', 'respond'}, extra={}), 'AgentLG#dc17c9b2': NegotiatorInfo(key='AgentLG#dc17c9b2', 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', 'anac', 'propose', 'respond', 'anac-2012'}, extra={}), 'AgentLarry#20d0568c': NegotiatorInfo(key='AgentLarry#20d0568c', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'AgentLight#c01509fc': NegotiatorInfo(key='AgentLight#c01509fc', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'AgentM#ccf8e47e': NegotiatorInfo(key='AgentM#ccf8e47e', 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', 'anac', 'propose', 'respond'}, extra={}), 'AgentMR#9e4858da': NegotiatorInfo(key='AgentMR#9e4858da', 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', 'anac', 'propose', 'respond', 'anac-2012'}, extra={}), 'AgentNP1#d55e709a': NegotiatorInfo(key='AgentNP1#d55e709a', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'AgentNeo#85ad4b0b': NegotiatorInfo(key='AgentNeo#85ad4b0b', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'AgentQuest#d5d4f3d6': NegotiatorInfo(key='AgentQuest#d5d4f3d6', 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', 'anac', 'propose', 'respond'}, extra={}), 'AgentSmith#5adcb427': NegotiatorInfo(key='AgentSmith#5adcb427', 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', 'propose', 'respond', 'anac-2010'}, extra={}), 'AgentSmith2016#74b8d9a1': NegotiatorInfo(key='AgentSmith2016#74b8d9a1', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'AgentTD#a1ae699a': NegotiatorInfo(key='AgentTD#a1ae699a', 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', 'anac', 'propose', 'respond'}, extra={}), 'AgentTRP#c13f6aec': NegotiatorInfo(key='AgentTRP#c13f6aec', 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', 'anac', 'propose', 'respond'}, extra={}), 'AgentW#1c35b6ab': NegotiatorInfo(key='AgentW#1c35b6ab', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'AgentX#7f40b6c0': NegotiatorInfo(key='AgentX#7f40b6c0', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'AgentYK#ccc665c9': NegotiatorInfo(key='AgentYK#ccc665c9', 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', 'anac', 'propose', 'respond'}, extra={}), 'AgreeableAgent2018#293a4252': NegotiatorInfo(key='AgreeableAgent2018#293a4252', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'AnacSampleAgent#da058210': NegotiatorInfo(key='AnacSampleAgent#da058210', 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', 'anac', 'propose', 'respond'}, extra={}), 'AresParty#3630f38e': NegotiatorInfo(key='AresParty#3630f38e', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'ArisawaYaki#91eeebb3': NegotiatorInfo(key='ArisawaYaki#91eeebb3', 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', 'anac', 'propose', 'respond'}, extra={}), 'AspirationNegotiator#275a15d5': NegotiatorInfo(key='AspirationNegotiator#275a15d5', short_name='AspirationNegotiator', full_type_name='negmas.gb.negotiators.timebased.AspirationNegotiator', cls=<class 'negmas.gb.negotiators.timebased.AspirationNegotiator'>, source='negmas', description='A time-based conceding negotiator with a simplified interface.\n\nThis is the most commonly used negotiator in the library. It concedes over\ntime according to a polynomial aspiration curve (boulware / linear /\nconceder, or a custom exponent) and uses an `InverseUFun` to find outcomes\nwithin the current aspiration band.\n\nArgs:\n    max_aspiration (float): The aspiration level (relative utility in\n        ``[0, 1]``) to use for the first offer (and first acceptance\n        decision). Defaults to ``1.0`` (start at the best outcome).\n    aspiration_type (str | float): The polynomial aspiration curve type.\n        Pass a string (``"boulware"`` for slow concession, ``"linear"``\n        for constant-rate concession, ``"conceder"`` for fast concession)\n        or a real-valued exponent. Defaults to ``"boulware"``.\n    stochastic (bool): If ``False`` (default), the negotiator proposes the\n        outcome with the *lowest* utility still within its aspiration band\n        (i.e. just above the aspiration level) via ``worst_in``. If\n        ``True``, it proposes a random in-range outcome via ``one_in``.\n    presort (bool): If ``True`` (default), a `DefaultInverseUtilityFunction`\n        (i.e. `AdaptiveInverseUtilityFunction`) is used, which presorts\n        outcomes for exact ``O(log n)`` lookups on small/medium spaces and\n        falls back to BIDS for large additive spaces. If ``False``, no\n        inverter is used and the negotiator cannot propose (it will always\n        fall back to the best outcome).\n    tolerance (float): A tolerance used for sampling outcomes near the\n        aspiration level (passed as ``eps`` to the inverter). Defaults to\n        ``0.001``.\n    ufun_inverter (type[InverseUFun] | None): An optional `InverseUFun`\n        **type** to use for inverting the utility function. If given, it\n        overrides the ``presort`` default. See `negmas.preferences.inv_ufun`\n        for the full list of available inverters and their trade-offs.\n    **kwargs: Forwarded to `TimeBasedConcedingNegotiator` (e.g.\n        ``name``, ``ufun``, ``parent``, ``owner``).\n\nRemarks:\n    - This class provides a simpler interface to\n      `TimeBasedConcedingNegotiator` with less control over the accepting\n      curve and offer selector. For more control, use\n      `TimeBasedConcedingNegotiator` or `TimeBasedNegotiator` directly.\n    - ``propose`` never returns ``None`` mid-negotiation: if the inverter\n      finds no outcome in the aspiration range (e.g. for strict inverters\n      like `BruteForceInverseUtilityFunction`, or when the aspiration band\n      is empty), it falls back to the best outcome rather than breaking the\n      SAO mechanism.', params={}, tags={'aspiration', 'propose', 'respond', 'time-based', 'builtin', 'sao'}, extra={}), 'Aster#8f285efb': NegotiatorInfo(key='Aster#8f285efb', 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', 'anac', 'propose', 'respond'}, extra={}), 'AteamAgent#c1895379': NegotiatorInfo(key='AteamAgent#c1895379', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'Ateamagent#749e3684': NegotiatorInfo(key='Ateamagent#749e3684', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'Atlas#ff7c6f62': NegotiatorInfo(key='Atlas#ff7c6f62', 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', 'anac', 'propose', 'respond'}, extra={}), 'Atlas3#13b78449': NegotiatorInfo(key='Atlas3#13b78449', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'Atlas32016#9030b95b': NegotiatorInfo(key='Atlas32016#9030b95b', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'BayesianAgent#828ccc2a': NegotiatorInfo(key='BayesianAgent#828ccc2a', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'BestOfferOrientedTBNegotiator#7a28e232': NegotiatorInfo(key='BestOfferOrientedTBNegotiator#7a28e232', short_name='BestOfferOrientedTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.BestOfferOrientedTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.BestOfferOrientedTBNegotiator'>, source='negmas', description="A time-based negotiator that selectes outcomes from the list allowed by the  current utility level based on their utility value and how near they are to the partner's past offer with the highest utility for me", params={}, tags={'offer-oriented', 'propose', 'respond', 'time-based', 'builtin', 'sao'}, extra={}), 'BetaOne#a307d2d7': NegotiatorInfo(key='BetaOne#a307d2d7', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'Betaone#70f4f7e6': NegotiatorInfo(key='Betaone#70f4f7e6', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'BinaryComparatorNegotiator#c68dcc3f': NegotiatorInfo(key='BinaryComparatorNegotiator#c68dcc3f', short_name='BinaryComparatorNegotiator', full_type_name='negmas.negotiators.simple.BinaryComparatorNegotiator', cls=<class 'negmas.negotiators.simple.BinaryComparatorNegotiator'>, source='negmas', description='A negotiator that can be asked to compare two outcomes using is_better. By default is just consults the ufun.\n\nTo change that behavior, override `is_better`.\n\nIt has the `compare-binary` capability.', params={}, tags={'elicitation', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'BoulwareNegotiationParty#56274154': NegotiatorInfo(key='BoulwareNegotiationParty#56274154', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'BoulwareTBNegotiator#83064835': NegotiatorInfo(key='BoulwareTBNegotiator#83064835', short_name='BoulwareTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.BoulwareTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.BoulwareTBNegotiator'>, source='negmas', description='A time-based negotiator that concedes sub-linearly (boulware).\n\nUses a `PolyAspiration` curve with exponent 4 (``"boulware"``) and\n``stochastic=False`` (proposes the worst outcome within the aspiration band).', params={}, tags={'boulware', 'propose', 'respond', 'time-based', 'builtin', 'sao'}, extra={}), 'BramAgent#93fbd7eb': NegotiatorInfo(key='BramAgent#93fbd7eb', 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', 'anac', 'anac-2011', 'propose', 'respond'}, extra={}), 'BramAgent2#a6140cfc': NegotiatorInfo(key='BramAgent2#a6140cfc', 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', 'anac', 'anac-2011', 'propose', 'respond'}, extra={}), 'BraveCat#fd81d5d9': NegotiatorInfo(key='BraveCat#fd81d5d9', 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', 'anac', 'propose', 'respond'}, extra={}), 'CABNegotiator#907c9f08': NegotiatorInfo(key='CABNegotiator#907c9f08', 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={'learning', 'propose', 'respond', 'cab-family', 'builtin', 'sao'}, extra={}), 'CANNegotiator#a36c3de5': NegotiatorInfo(key='CANNegotiator#a36c3de5', 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={'learning', 'propose', 'respond', 'cab-family', 'builtin', 'sao'}, extra={}), 'CARNegotiator#d490b719': NegotiatorInfo(key='CARNegotiator#d490b719', 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={'learning', 'propose', 'respond', 'cab-family', 'builtin', 'sao'}, extra={}), 'CUHKAgent#dade852e': NegotiatorInfo(key='CUHKAgent#dade852e', 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', 'anac', 'propose', 'respond', 'anac-2012'}, extra={}), 'CUHKAgent2015#7a7ef291': NegotiatorInfo(key='CUHKAgent2015#7a7ef291', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'Caduceus#e361910b': NegotiatorInfo(key='Caduceus#e361910b', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'CaduceusDC16#fdabce85': NegotiatorInfo(key='CaduceusDC16#fdabce85', 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', 'anac', 'propose', 'respond'}, extra={}), 'ClockworkAgent#d347aa20': NegotiatorInfo(key='ClockworkAgent#d347aa20', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'ConDAgent#41c5aea1': NegotiatorInfo(key='ConDAgent#41c5aea1', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'ConcederNegotiationParty#71f37d8c': NegotiatorInfo(key='ConcederNegotiationParty#71f37d8c', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'ConcederTBNegotiator#3fac8a7a': NegotiatorInfo(key='ConcederTBNegotiator#3fac8a7a', short_name='ConcederTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.ConcederTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.ConcederTBNegotiator'>, source='negmas', description='A time-based negotiator that concedes super-linearly (conceder).\n\nUses a `PolyAspiration` curve with exponent 0.25 (``"conceder"``) and\n``stochastic=False``.', params={}, tags={'conceder', 'propose', 'respond', 'time-based', 'builtin', 'sao'}, extra={}), 'DandikAgent#49130d6e': NegotiatorInfo(key='DandikAgent#49130d6e', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'DoNA#f8135045': NegotiatorInfo(key='DoNA#f8135045', 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', 'anac', 'propose', 'respond'}, extra={}), 'DrageKnight#77ab4620': NegotiatorInfo(key='DrageKnight#77ab4620', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'E2Agent#636eafcc': NegotiatorInfo(key='E2Agent#636eafcc', 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', 'anac', 'propose', 'respond'}, extra={}), 'EAgent#ea86fc6b': NegotiatorInfo(key='EAgent#ea86fc6b', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'ExpRubick#41473b53': NegotiatorInfo(key='ExpRubick#41473b53', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'FSEGA2019#9f28d9f8': NegotiatorInfo(key='FSEGA2019#9f28d9f8', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'Farma#285a7e8b': NegotiatorInfo(key='Farma#285a7e8b', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'Farma17#1cd9320c': NegotiatorInfo(key='Farma17#1cd9320c', 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', 'anac', 'propose', 'respond'}, extra={}), 'Farma2017#97503c04': NegotiatorInfo(key='Farma2017#97503c04', 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', 'anac', 'propose', 'respond'}, extra={}), 'FastMiCRONegotiator#6a81e9be': NegotiatorInfo(key='FastMiCRONegotiator#6a81e9be', short_name='FastMiCRONegotiator', full_type_name='negmas.gb.negotiators.micro.FastMiCRONegotiator', cls=<class 'negmas.gb.negotiators.micro.FastMiCRONegotiator'>, source='negmas', description='Rational Concession Negotiator that can skip outcomes so as to traverse the\nwhole outcome list before the deadline.\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.\n     accept_same: Accept an offer equal in utility to our own next offer.\n     forced_concession_time: Relative time after which concession is allowed\n         even if we already sent more offers than we received.\n     min_time_before_skipping: Skipping is disabled before this relative time.\n     min_offers_before_skipping: Skipping is disabled until this many offers\n         have been sent.\n     expected_offers_rounding: Added before truncating the estimated number of\n         remaining offers (``0.5`` rounds to nearest).\n     offering: A ready `FastMiCROOfferingPolicy` to use instead of building\n         one from the arguments above (which are then ignored).\n     acceptance: A ready `AcceptancePolicy` to use instead of\n         `MiCROAcceptancePolicy`.', params={}, tags={'learning', 'propose', 'respond', 'builtin', 'micro', 'sao'}, extra={}), 'FirstOfferOrientedTBNegotiator#746637d3': NegotiatorInfo(key='FirstOfferOrientedTBNegotiator#746637d3', short_name='FirstOfferOrientedTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.FirstOfferOrientedTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.FirstOfferOrientedTBNegotiator'>, source='negmas', description="A time-based negotiator that selectes outcomes from the list allowed by the  current utility level based on their utility value and how near they are to the partner's first offer", params={}, tags={'offer-oriented', 'propose', 'respond', 'time-based', 'builtin', 'sao'}, extra={}), 'Flinch#87a848c9': NegotiatorInfo(key='Flinch#87a848c9', 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', 'anac', 'propose', 'respond'}, extra={}), 'FullAgent#eb4574db': NegotiatorInfo(key='FullAgent#eb4574db', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'FunctionalAcceptor#a0c3d94a': NegotiatorInfo(key='FunctionalAcceptor#a0c3d94a', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'FuzzyAgent#1581d46b': NegotiatorInfo(key='FuzzyAgent#1581d46b', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'GAgent#6ec3e0e5': NegotiatorInfo(key='GAgent#6ec3e0e5', 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', 'anac-2013', 'anac', 'propose', 'respond'}, extra={}), 'GAgentK#5d997050': NegotiatorInfo(key='GAgentK#5d997050', short_name='GAgentK', full_type_name='negmas.genius.gboa_negotiators.GAgentK', cls=<class 'negmas.genius.gboa_negotiators.GAgentK'>, source='negmas', description='ANAC 2010 agent: time-dependent offering with combined-condition (AC_Combi) acceptance and a basic opponent model.', params={}, tags={'time-based', 'opponent-modeling', 'genius', 'gb', 'anac', 'propose', 'respond', 'boa', 'anac-2010'}, extra={}), 'GAgentLG#217ff5a0': NegotiatorInfo(key='GAgentLG#217ff5a0', short_name='GAgentLG', full_type_name='negmas.genius.gboa_negotiators.GAgentLG', cls=<class 'negmas.genius.gboa_negotiators.GAgentLG'>, source='negmas', description='ANAC 2012 agent: time-dependent offering with AC_CombiMax acceptance and frequency-based opponent modeling.', params={}, tags={'time-based', 'opponent-modeling', 'anac-2012', 'genius', 'gb', 'anac', 'propose', 'respond', 'boa'}, extra={}), 'GAgentSmith#69e4c77c': NegotiatorInfo(key='GAgentSmith#69e4c77c', short_name='GAgentSmith', full_type_name='negmas.genius.gboa_negotiators.GAgentSmith', cls=<class 'negmas.genius.gboa_negotiators.GAgentSmith'>, source='negmas', description='ANAC 2010 agent: time-dependent offering with a fixed acceptance threshold and Smith-style frequency-based opponent modeling.', params={}, tags={'time-based', 'opponent-modeling', 'genius', 'gb', 'anac', 'propose', 'respond', 'boa', 'anac-2010'}, extra={}), 'GAgentX#7cb0f12b': NegotiatorInfo(key='GAgentX#7cb0f12b', short_name='GAgentX', full_type_name='negmas.genius.gboa_negotiators.GAgentX', cls=<class 'negmas.genius.gboa_negotiators.GAgentX'>, source='negmas', description='ANAC 2015 agent: adaptive time-dependent offering with window-based acceptance and exponential-smoothing opponent modeling.', params={}, tags={'time-based', 'opponent-modeling', 'genius', 'gb', 'anac-2015', 'anac', 'propose', 'respond', 'boa'}, extra={}), 'GBoulware#03e11b01': NegotiatorInfo(key='GBoulware#03e11b01', short_name='GBoulware', full_type_name='negmas.genius.gboa_negotiators.GBoulware', cls=<class 'negmas.genius.gboa_negotiators.GBoulware'>, source='negmas', description='Boulware-style time-dependent negotiator (e=0.2) that concedes slowly and only makes significant concessions near the deadline.', params={}, tags={'genius', 'gb', 'boulware', 'propose', 'respond', 'boa', 'time-based'}, extra={}), 'GCUHKAgent#6fbc6094': NegotiatorInfo(key='GCUHKAgent#6fbc6094', short_name='GCUHKAgent', full_type_name='negmas.genius.gboa_negotiators.GCUHKAgent', cls=<class 'negmas.genius.gboa_negotiators.GCUHKAgent'>, source='negmas', description='ANAC 2012 winner: conservative time-dependent offering with combined acceptance conditions and frequency-based opponent modeling, tuned for discounted domains.', params={}, tags={'time-based', 'opponent-modeling', 'anac-2012', 'genius', 'gb', 'anac', 'propose', 'respond', 'boa'}, extra={}), 'GConceder#08b81fba': NegotiatorInfo(key='GConceder#08b81fba', short_name='GConceder', full_type_name='negmas.genius.gboa_negotiators.GConceder', cls=<class 'negmas.genius.gboa_negotiators.GConceder'>, source='negmas', description='Conceder-style time-dependent negotiator (e=2.0) that concedes quickly early in the negotiation.', params={}, tags={'genius', 'gb', 'conceder', 'propose', 'respond', 'boa', 'time-based'}, extra={}), 'GFSEGA#32250f9e': NegotiatorInfo(key='GFSEGA#32250f9e', short_name='GFSEGA', full_type_name='negmas.genius.gboa_negotiators.GFSEGA', cls=<class 'negmas.genius.gboa_negotiators.GFSEGA'>, source='negmas', description='ANAC 2010 agent (FSEGA): conceding time-dependent offering strategy with a fixed acceptance threshold.', params={}, tags={'conceder', 'time-based', 'opponent-modeling', 'genius', 'gb', 'anac', 'propose', 'respond', 'boa', 'anac-2010'}, extra={}), 'GHardHeaded#296bb371': NegotiatorInfo(key='GHardHeaded#296bb371', short_name='GHardHeaded', full_type_name='negmas.genius.gboa_negotiators.GHardHeaded', cls=<class 'negmas.genius.gboa_negotiators.GHardHeaded'>, source='negmas', description='ANAC 2011 winner: Boulware-style time-dependent offering combined with frequency-based opponent modeling of unchanged issues to infer opponent preferences.', params={}, tags={'anac-2011', 'time-based', 'opponent-modeling', 'genius', 'gb', 'anac', 'propose', 'respond', 'boa'}, extra={}), 'GHardliner#ae25791d': NegotiatorInfo(key='GHardliner#ae25791d', short_name='GHardliner', full_type_name='negmas.genius.gboa_negotiators.GHardliner', cls=<class 'negmas.genius.gboa_negotiators.GHardliner'>, source='negmas', description='Time-dependent negotiator (e=0) that never concedes and always offers its best outcome.', params={}, tags={'genius', 'gb', 'hardliner', 'propose', 'respond', 'boa', 'time-based'}, extra={}), 'GLinear#aec29133': NegotiatorInfo(key='GLinear#aec29133', short_name='GLinear', full_type_name='negmas.genius.gboa_negotiators.GLinear', cls=<class 'negmas.genius.gboa_negotiators.GLinear'>, source='negmas', description='Time-dependent negotiator (e=1.0) that concedes at a constant rate throughout the negotiation.', params={}, tags={'genius', 'gb', 'propose', 'respond', 'boa', 'time-based', 'linear'}, extra={}), 'GNozomi#1b5aa35a': NegotiatorInfo(key='GNozomi#1b5aa35a', short_name='GNozomi', full_type_name='negmas.genius.gboa_negotiators.GNozomi', cls=<class 'negmas.genius.gboa_negotiators.GNozomi'>, source='negmas', description="ANAC 2010 agent: Boulware-style time-dependent offering with AC_Previous acceptance (accepts if better than the opponent's previous offer).", params={}, tags={'time-based', 'opponent-modeling', 'genius', 'gb', 'anac', 'propose', 'respond', 'boa', 'anac-2010'}, extra={}), 'GRandom#b91e8fa8': NegotiatorInfo(key='GRandom#b91e8fa8', short_name='GRandom', full_type_name='negmas.genius.gboa_negotiators.GRandom', cls=<class 'negmas.genius.gboa_negotiators.GRandom'>, source='negmas', description='Baseline negotiator that makes random offers and accepts any offer.', params={}, tags={'genius', 'gb', 'random', 'propose', 'respond', 'boa'}, extra={}), 'Gahboninho#58479e50': NegotiatorInfo(key='Gahboninho#58479e50', 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', 'anac', 'anac-2011', 'propose', 'respond'}, extra={}), 'Gangester#9ed530a4': NegotiatorInfo(key='Gangester#9ed530a4', 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', 'anac', 'propose', 'respond'}, extra={}), 'Gangster#1172e7de': NegotiatorInfo(key='Gangster#1172e7de', 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', 'anac', 'propose', 'respond'}, extra={}), 'GaravelAgent#30e06fd1': NegotiatorInfo(key='GaravelAgent#30e06fd1', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'GeneKing#e7908115': NegotiatorInfo(key='GeneKing#e7908115', 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', 'anac', 'propose', 'respond'}, extra={}), 'Gin#b439213a': NegotiatorInfo(key='Gin#b439213a', 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', 'anac', 'propose', 'respond'}, extra={}), 'GrandmaAgent#2407b912': NegotiatorInfo(key='GrandmaAgent#2407b912', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'Gravity#c9ad5e26': NegotiatorInfo(key='Gravity#c9ad5e26', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'Group1#dbdae35e': NegotiatorInfo(key='Group1#dbdae35e', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group10#4cd78a4d': NegotiatorInfo(key='Group10#4cd78a4d', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group11#1dcbc78c': NegotiatorInfo(key='Group11#1dcbc78c', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group12#5b2de875': NegotiatorInfo(key='Group12#5b2de875', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group13#924814d0': NegotiatorInfo(key='Group13#924814d0', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group14#ef5249c8': NegotiatorInfo(key='Group14#ef5249c8', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group15#1bdb211b': NegotiatorInfo(key='Group15#1bdb211b', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group16#7300df92': NegotiatorInfo(key='Group16#7300df92', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group17#614a31b0': NegotiatorInfo(key='Group17#614a31b0', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group18#581a849e': NegotiatorInfo(key='Group18#581a849e', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group19#a8c34db1': NegotiatorInfo(key='Group19#a8c34db1', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group1BOA#9bd746ca': NegotiatorInfo(key='Group1BOA#9bd746ca', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'Group2#c21bfd4d': NegotiatorInfo(key='Group2#c21bfd4d', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'Group20#bb45beef': NegotiatorInfo(key='Group20#bb45beef', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group21#7231c6a7': NegotiatorInfo(key='Group21#7231c6a7', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group22#d54e009b': NegotiatorInfo(key='Group22#d54e009b', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group3#ace1b603': NegotiatorInfo(key='Group3#ace1b603', 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', 'anac', 'propose', 'respond'}, extra={}), 'Group3Q2015#b932345f': NegotiatorInfo(key='Group3Q2015#b932345f', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group4#135bb622': NegotiatorInfo(key='Group4#135bb622', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group5#61f93452': NegotiatorInfo(key='Group5#61f93452', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group6#6a8d7822': NegotiatorInfo(key='Group6#6a8d7822', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group7#193eff2e': NegotiatorInfo(key='Group7#193eff2e', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group8#c8c4bd95': NegotiatorInfo(key='Group8#c8c4bd95', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'Group9#b5d5d88b': NegotiatorInfo(key='Group9#b5d5d88b', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'GroupY#e20e43ba': NegotiatorInfo(key='GroupY#e20e43ba', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'HardDealer#1ec0dfd5': NegotiatorInfo(key='HardDealer#1ec0dfd5', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'HardHeaded#621e1434': NegotiatorInfo(key='HardHeaded#621e1434', 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', 'anac', 'anac-2011', 'propose', 'respond'}, extra={}), 'HybridNegotiator#e2d74866': NegotiatorInfo(key='HybridNegotiator#e2d74866', short_name='HybridNegotiator', full_type_name='negmas.gb.negotiators.hybrid.HybridNegotiator', cls=<class 'negmas.gb.negotiators.hybrid.HybridNegotiator'>, source='negmas', description="A negotiator mixing a time-based (Bezier) concession curve with a\nbehaviour-based reaction to the opponent, accepting via ACnext.\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.\n     alpha: ACnext utility scale (see `ACNext`).\n     beta: ACnext utility offset (see `ACNext`).\n     initial_utility: Bezier control point at ``t=0``. ``NaN`` means *auto*\n         (see `HybridOfferingPolicy`).\n     concession_ratio: Middle Bezier control point. ``NaN`` means *auto*.\n     final_utility: Bezier control point at ``t=1``. ``NaN`` means *auto*\n         (derived from the domain size).\n     empathy_score: How strongly the opponent's concession moves our target.\n         ``NaN`` means *auto*.\n     auto_initial_utility: ``initial_utility`` used in auto mode.\n     auto_concession_ratio: ``concession_ratio`` used in auto mode.\n     auto_empathy_score: ``empathy_score`` used in auto mode.\n     domain_size_cap: Domain cardinality is clipped to this before consulting\n         ``final_utility_ladder``.\n     final_utility_ladder: Ordered ``(max_domain_size, final_utility)`` pairs\n         used to derive ``final_utility`` in auto mode.\n     final_utility_floor: ``final_utility`` in auto mode for domains larger\n         than every ladder threshold.\n     behavior_min_offers: Offers to receive before mixing in the\n         behaviour-based component.\n     enumeration_levels: Discretization levels for continuous outcome spaces.\n     enumeration_max_cardinality: Max outcomes enumerated for continuous\n         outcome spaces.\n     frac_time_based: Window weights over the opponent's recent utility\n         differences.\n     above_only: Only consider outcomes at or above the target utility.\n     offering: A ready `HybridOfferingPolicy` to use instead of building one\n         from the arguments above (which are then ignored).\n     acceptance: A ready `AcceptancePolicy` to use instead of `ACNext`.\n\nRemarks:\n    - Every hyperparameter of `HybridOfferingPolicy` is reachable here, so\n      the negotiator can be tuned without constructing components by hand.", params={}, tags={'hybrid', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'IAMcrazyHaggler#ea5cdf06': NegotiatorInfo(key='IAMcrazyHaggler#ea5cdf06', 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', 'propose', 'respond', 'anac-2010'}, extra={}), 'IAMhaggler#39299940': NegotiatorInfo(key='IAMhaggler#39299940', 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', 'propose', 'respond', 'anac-2010'}, extra={}), 'IAMhaggler2011#d2cabea0': NegotiatorInfo(key='IAMhaggler2011#d2cabea0', 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', 'anac', 'anac-2011', 'propose', 'respond'}, extra={}), 'IAMhaggler2012#ece45629': NegotiatorInfo(key='IAMhaggler2012#ece45629', 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', 'anac', 'propose', 'respond', 'anac-2012'}, extra={}), 'IQSun2018#62fe634e': NegotiatorInfo(key='IQSun2018#62fe634e', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'Imitator#33d93372': NegotiatorInfo(key='Imitator#33d93372', 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', 'anac', 'propose', 'respond'}, extra={}), 'ImmediateAcceptor#997344ef': NegotiatorInfo(key='ImmediateAcceptor#997344ef', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'InoxAgent#e238b49a': NegotiatorInfo(key='InoxAgent#e238b49a', 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', 'anac-2013', 'anac', 'propose', 'respond'}, extra={}), 'JonnyBlack#7148ba3a': NegotiatorInfo(key='JonnyBlack#7148ba3a', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'KAgent#f63e4774': NegotiatorInfo(key='KAgent#f63e4774', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'KGAgent#d7f27f14': NegotiatorInfo(key='KGAgent#d7f27f14', 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', 'anac', 'propose', 'respond'}, extra={}), 'KakeSoba#5f711360': NegotiatorInfo(key='KakeSoba#5f711360', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'Kawaii#9438a7e9': NegotiatorInfo(key='Kawaii#9438a7e9', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'Lancelot#d412c3e3': NegotiatorInfo(key='Lancelot#d412c3e3', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'LastOfferOrientedTBNegotiator#74d4caa3': NegotiatorInfo(key='LastOfferOrientedTBNegotiator#74d4caa3', short_name='LastOfferOrientedTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.LastOfferOrientedTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.LastOfferOrientedTBNegotiator'>, source='negmas', description="A time-based negotiator that selectes outcomes from the list allowed by the  current utility level based on their utility value and how near they are to the partner's last offer", params={}, tags={'offer-oriented', 'propose', 'respond', 'time-based', 'builtin', 'sao'}, extra={}), 'Libra#da1a2acb': NegotiatorInfo(key='Libra#da1a2acb', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'LimitedOutcomesAcceptor#7a481b4b': NegotiatorInfo(key='LimitedOutcomesAcceptor#7a481b4b', 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={'propose', 'respond', 'limited-outcomes', 'builtin', 'sao'}, extra={}), 'LimitedOutcomesNegotiator#42080677': NegotiatorInfo(key='LimitedOutcomesNegotiator#42080677', 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    default_acceptance_probability: acceptance probability used when neither\n        `acceptable_outcomes` nor `acceptance_probabilities` is given.\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={'propose', 'respond', 'limited-outcomes', 'builtin', 'sao'}, extra={}), 'LinearTBNegotiator#a43cde3b': NegotiatorInfo(key='LinearTBNegotiator#a43cde3b', short_name='LinearTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.LinearTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.LinearTBNegotiator'>, source='negmas', description='A time-based negotiator that concedes linearly.\n\nUses a `PolyAspiration` curve with exponent 1 (``"linear"``) and\n``stochastic=False``.', params={}, tags={'linear', 'propose', 'respond', 'time-based', 'builtin', 'sao'}, extra={}), 'MINF#ddecb803': NegotiatorInfo(key='MINF#ddecb803', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'MadAgent#7510ff9f': NegotiatorInfo(key='MadAgent#7510ff9f', 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', 'anac', 'propose', 'respond'}, extra={}), 'Mamenchis#e7c9db11': NegotiatorInfo(key='Mamenchis#e7c9db11', 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', 'anac', 'propose', 'respond'}, extra={}), 'MaxOops#bb51d2f7': NegotiatorInfo(key='MaxOops#bb51d2f7', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'MeanBot#725bbde2': NegotiatorInfo(key='MeanBot#725bbde2', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'MeanMetaNegotiator#cc365d63': NegotiatorInfo(key='MeanMetaNegotiator#cc365d63', 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', 'propose', 'respond', 'builtin', 'meta', 'sao'}, extra={}), 'MengWan#0e84a81d': NegotiatorInfo(key='MengWan#0e84a81d', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'Mercury#abe97d48': NegotiatorInfo(key='Mercury#abe97d48', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'MetaAgent#371c3f6e': NegotiatorInfo(key='MetaAgent#371c3f6e', 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', 'anac', 'propose', 'respond', 'anac-2012'}, extra={}), 'MetaAgent2012#a9718a50': NegotiatorInfo(key='MetaAgent2012#a9718a50', 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', 'anac', 'propose', 'respond', 'anac-2012'}, extra={}), 'MetaAgent2013#079aa926': NegotiatorInfo(key='MetaAgent2013#079aa926', 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', 'anac-2013', 'anac', 'propose', 'respond'}, extra={}), 'MiCRONegotiator#f4a4e211': NegotiatorInfo(key='MiCRONegotiator#f4a4e211', 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.\n     accept_same: Accept an offer equal in utility to our own next offer.\n     offering: A ready `MiCROOfferingPolicy` to use instead of the default.\n     acceptance: A ready `AcceptancePolicy` to use instead of\n         `MiCROAcceptancePolicy`.', params={}, tags={'learning', 'propose', 'respond', 'builtin', 'micro', 'sao'}, extra={}), 'Mosa#bd4194fc': NegotiatorInfo(key='Mosa#bd4194fc', 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', 'anac', 'propose', 'respond'}, extra={}), 'MultiplicativeFirstFollowingTBNegotiator#d1b560f3': NegotiatorInfo(key='MultiplicativeFirstFollowingTBNegotiator#d1b560f3', short_name='MultiplicativeFirstFollowingTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.MultiplicativeFirstFollowingTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.MultiplicativeFirstFollowingTBNegotiator'>, source='negmas', description='A time-based negotiator that selectes outcomes from the list allowed by the\ncurrent utility level based on a weighted sum of their normalized utilities and\ndistances to previous offers', params={}, tags={'propose', 'respond', 'time-based', 'builtin', 'following', 'sao'}, extra={}), 'MultiplicativeLastOfferFollowingTBNegotiator#18648fd3': NegotiatorInfo(key='MultiplicativeLastOfferFollowingTBNegotiator#18648fd3', short_name='MultiplicativeLastOfferFollowingTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.MultiplicativeLastOfferFollowingTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.MultiplicativeLastOfferFollowingTBNegotiator'>, source='negmas', description='A time-based negotiator that selectes outcomes from the list allowed by the\ncurrent utility level based on a weighted sum of their normalized utilities and\ndistances to previous offers', params={}, tags={'propose', 'respond', 'time-based', 'builtin', 'following', 'sao'}, extra={}), 'MultiplicativeParetoFollowingTBNegotiator#2c5763d3': NegotiatorInfo(key='MultiplicativeParetoFollowingTBNegotiator#2c5763d3', short_name='MultiplicativeParetoFollowingTBNegotiator', full_type_name='negmas.gb.negotiators.timebased.MultiplicativeParetoFollowingTBNegotiator', cls=<class 'negmas.gb.negotiators.timebased.MultiplicativeParetoFollowingTBNegotiator'>, source='negmas', description='A time-based negotiator that selectes outcomes from the list allowed by the\ncurrent utility level based on a weighted sum of their normalized utilities and\ndistances to previous offers', params={}, tags={'propose', 'respond', 'time-based', 'builtin', 'following', 'sao'}, extra={}), 'MyAgent#be1a3d37': NegotiatorInfo(key='MyAgent#be1a3d37', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'NLevelsComparatorNegotiator#21a3ef84': NegotiatorInfo(key='NLevelsComparatorNegotiator#21a3ef84', short_name='NLevelsComparatorNegotiator', full_type_name='negmas.negotiators.simple.NLevelsComparatorNegotiator', cls=<class 'negmas.negotiators.simple.NLevelsComparatorNegotiator'>, source='negmas', description='A negotiator that can be asked to compare two outcomes using compare_nlevels which returns the strength of\nthe difference between two outcomes as an integer from [-n, n] in the C compare sense.\nBy default is just consults the ufun.\n\nTo change that behavior, override `compare_nlevels`.\n\nIt has the `compare-nlevels` capability.', params={}, tags={'elicitation', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'NaiveTitForTatNegotiator#a4cb8a02': NegotiatorInfo(key='NaiveTitForTatNegotiator#a4cb8a02', 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\navailability of an opponent model.\n\nThe negotiator mirrors the opponent\'s concession: if the opponent\'s last\noffer was better for this negotiator than the one before it, the negotiator\nconsiders that the opponent has conceded by the difference and concedes a\nmatching amount (adjusted by ``kindness``). This implicitly assumes a\nzero-sum situation (no opponent model is kept).\n\nArgs:\n    name: Negotiator name.\n    preferences: Negotiator preferences (deprecated; use ``ufun``).\n    ufun: Negotiator utility function (overrides ``preferences``).\n    parent: A controller that manages this negotiator.\n    kindness (float): How \'kind\' the agent is. ``0.0`` is standard\n        tit-for-tat. Positive values make the negotiator concede faster;\n        negative values make it concede slower. Defaults to ``0.0``.\n    stochastic (bool): If ``True``, offers are randomized within the band\n        determined by the current concession (which reflects the\n        opponent\'s concession). If ``False`` (default), the worst outcome\n        in the band is proposed. Defaults to ``False``.\n    punish (bool): If ``True``, the agent punishes a partner who does not\n        concede by requiring higher utilities. Defaults to ``False``.\n    initial_concession (float | str): How much the agent should concede at\n        the beginning, in utility units. Can be a non-negative float or the\n        string ``"min"`` (treated as ``0.0`` — minimum concession).\n        Defaults to ``"min"``.\n    rank_only (bool): If ``True``, only the relative ranks of outcomes (not\n        their actual utilities) are used for inversion. Defaults to ``False``.\n    must_concede (bool): If ``True`` (default) the negotiator is guaranteed\n        to make a (minimal) concession on its second call. Forwarded to\n        `KindConcessionRecommender`.\n    no_concession_step (int): Steps at or below this index get zero\n        concession. Forwarded to `KindConcessionRecommender`.\n    kindness_start_step (int): From this step onward the recommendation is\n        simply the partner\'s concession plus ``kindness``. Forwarded to\n        `KindConcessionRecommender`.\n    min_concession_eps (float): Numerical slack added to the smallest\n        representable utility gap when ``must_concede`` forces a minimal\n        concession. Forwarded to `KindConcessionRecommender`.\n    **kwargs: Forwarded to `MAPNegotiator`.\n\nRemarks:\n    - This negotiator does not keep an opponent model. It thinks only in\n      terms of changes in its own utility. If the opponent\'s last offer\n      was better for the negotiator compared with the one before it, it\n      considers that the opponent has conceded by the difference. This\n      means that it implicitly assumes a zero-sum situation.', params={}, tags={'tit-for-tat', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'Ngent#a538a9f3': NegotiatorInfo(key='Ngent#a538a9f3', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'NiceNegotiator#30b15142': NegotiatorInfo(key='NiceNegotiator#30b15142', 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={'aspiration', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'NiceTitForTat#3c621326': NegotiatorInfo(key='NiceTitForTat#3c621326', 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', 'anac', 'anac-2011', 'propose', 'respond'}, extra={}), 'NiceTitForTatNegotiator#3671ebf3': NegotiatorInfo(key='NiceTitForTatNegotiator#3671ebf3', short_name='NiceTitForTatNegotiator', full_type_name='negmas.gb.negotiators.titfortat.NiceTitForTatNegotiator', cls=<class 'negmas.gb.negotiators.titfortat.NiceTitForTatNegotiator'>, source='negmas', description='The Nice Tit for Tat agent (Baarslag, Hindriks & Jonker, 2013).\n\nA MAP negotiator combining the `NiceTitForTatOfferingPolicy` bidding\nstrategy (reciprocate in the agent\'s own utility while aiming for a\nbargaining-solution point, and make offers attractive to the opponent) with\nthe `ACCombi` acceptance condition (accept when the opponent\'s offer beats\nour next planned offer, or when time is running out).\n\nThe opponent model is the one piece the bidding strategy depends on. It is\naccessed through the standard ``opponent_ufun`` property (read by the\noffering policy via ``self.negotiator.opponent_ufun``), populated\nautomatically from the model passed here. You can either:\n\n- pass a ready opponent model as ``opponent_model`` (any `UFunModel`,\n  e.g. a learned `FrequencyLinearUFunModel`, an oracle\n  `PeekingOpponentModel` for tests, or a `ZeroSumModel`), or\n- pass an opponent-model *type* as ``opponent_model_type`` (a `UFunModel`\n  subclass), constructed with no required args, or\n- pass neither and use the default: `FrequencyLinearUFunModel` — a\n  frequency-based learner assuming a linear-additive opponent ufun, the\n  same assumption as the Bayesian opponent model of Hindriks & Tykhonov\n  (2008) used in the paper. Use `FrequencyUFunModel` instead when the\n  opponent\'s ufun is not known to be linear-additive.\n\nArgs:\n    opponent_model: A ready `UFunModel` to use as the opponent model. Takes\n        precedence over ``opponent_model_type``.\n    opponent_model_type: A `UFunModel` subclass to instantiate as the\n        default opponent model. Defaults to `FrequencyLinearUFunModel`.\n    target: Bargaining solution the offering strategy aims for — one of\n        ``"nash"`` (default), ``"kalai"``, ``"kalai_smorodinsky"``/``"ks"``,\n        ``"max_welfare"``, ``"max_relative_welfare"``. Forwarded to\n        `NiceTitForTatOfferingPolicy`.\n    sample_size, max_cardinality, nash_refresh, stochastic, levels, nash_min:\n        Forwarded to `NiceTitForTatOfferingPolicy`.\n    nash_multiplier_base, nash_multiplier_gap_weight, default_nash_utility,\n    discount_bonus_base, discount_bonus_weight, big_domain_cardinality,\n    bonus_start_time, bonus_start_time_big_domain, bonus_ramp_rate:\n        The Baarslag reference constants of the bidding strategy, forwarded\n        to `NiceTitForTatOfferingPolicy`. Defaults reproduce the paper.\n    pareto_sampler_type: The `ParetoSampler` implementation used by the\n        offering policy for the opponent-attractive trade-off query.\n        ``None`` (default) uses the offering policy\'s own default\n        (`DefaultParetoSampler` / `AdaptiveParetoSampler` — exact\n        brute-force on small spaces, a scalable backend on large ones). Pass\n        a specific type (e.g. `IPSParetoSampler`) to override.\n    a, b, t: ACcombi parameters (forwarded to `ACCombi`).\n\nRemarks:\n    - Exposes ``opponent_model`` (the `UFunModel` in use) as a property.\n    - The offering policy degrades to naive tit-for-tat if the opponent\n      model is unavailable or uninformative.\n\n*AI Generated (Nice Tit for Tat MAP negotiator, after Baarslag et al. 2013).*', params={}, tags={'tit-for-tat', 'propose', 'respond', 'nash', 'builtin', 'opponent-modeling', 'sao'}, extra={}), 'Nozomi#bd2fc675': NegotiatorInfo(key='Nozomi#bd2fc675', 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', 'propose', 'respond', 'anac-2010'}, extra={}), 'OMACagent#3d500a1d': NegotiatorInfo(key='OMACagent#3d500a1d', 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', 'anac', 'propose', 'respond', 'anac-2012'}, extra={}), 'OSMeanMetaNegotiator#a9372f0e': NegotiatorInfo(key='OSMeanMetaNegotiator#a9372f0e', 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', 'propose', 'respond', 'builtin', 'meta', 'sao'}, extra={}), 'OptimalBidderSimple#9c645204': NegotiatorInfo(key='OptimalBidderSimple#9c645204', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'PNegotiator#c6c5fc33': NegotiatorInfo(key='PNegotiator#c6c5fc33', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'ParsAgent#63a9eedc': NegotiatorInfo(key='ParsAgent#63a9eedc', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'ParsAgent2#a598b3d2': NegotiatorInfo(key='ParsAgent2#a598b3d2', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'ParsAgent3#1b140adc': NegotiatorInfo(key='ParsAgent3#1b140adc', 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', 'anac', 'propose', 'respond'}, extra={}), 'ParsCat#e75efc64': NegotiatorInfo(key='ParsCat#e75efc64', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'ParsCat2#3cb8eb6e': NegotiatorInfo(key='ParsCat2#3cb8eb6e', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'PhoenixParty#ce02e41c': NegotiatorInfo(key='PhoenixParty#ce02e41c', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'PodAgent#792399a3': NegotiatorInfo(key='PodAgent#792399a3', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'PokerFace#47865506': NegotiatorInfo(key='PokerFace#47865506', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'PonPokoAgent#17ffdde7': NegotiatorInfo(key='PonPokoAgent#17ffdde7', 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', 'anac', 'propose', 'respond'}, extra={}), 'PonPokoRampage#cb38289d': NegotiatorInfo(key='PonPokoRampage#cb38289d', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'Q12015Group2#83303dca': NegotiatorInfo(key='Q12015Group2#83303dca', 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={'respond', 'genius', 'tudelft', 'propose'}, extra={}), 'RandomAlwaysAcceptingNegotiator#1e422fd1': NegotiatorInfo(key='RandomAlwaysAcceptingNegotiator#1e422fd1', 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={'random', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'RandomCounterOfferNegotiationParty#cb5198ff': NegotiatorInfo(key='RandomCounterOfferNegotiationParty#cb5198ff', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'RandomDance#acf10cc4': NegotiatorInfo(key='RandomDance#acf10cc4', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'RandomNegotiator#4d8cec2b': NegotiatorInfo(key='RandomNegotiator#4d8cec2b', 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={'random', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'RandomParty#75dfa675': NegotiatorInfo(key='RandomParty#75dfa675', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'RandomParty2#c8d6e2e8': NegotiatorInfo(key='RandomParty2#c8d6e2e8', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'RangeMetaNegotiator#2cf5db74': NegotiatorInfo(key='RangeMetaNegotiator#2cf5db74', 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', 'propose', 'respond', 'builtin', 'meta', 'sao'}, extra={}), 'RankerNegotiator#2fe1b331': NegotiatorInfo(key='RankerNegotiator#2fe1b331', short_name='RankerNegotiator', full_type_name='negmas.negotiators.simple.RankerNegotiator', cls=<class 'negmas.negotiators.simple.RankerNegotiator'>, source='negmas', description='A negotiator that can be asked to rank outcomes. By default is just consults the ufun.\n\nTo change that behavior, override `rank`.\n\nIt has the `rank` capability.', params={}, tags={'elicitation', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'RankerWithWeightsNegotiator#2d0b4cef': NegotiatorInfo(key='RankerWithWeightsNegotiator#2d0b4cef', short_name='RankerWithWeightsNegotiator', full_type_name='negmas.negotiators.simple.RankerWithWeightsNegotiator', cls=<class 'negmas.negotiators.simple.RankerWithWeightsNegotiator'>, source='negmas', description='A negotiator that can be asked to rank outcomes returning rank and weight. By default is just consults the ufun.\n\nTo change that behavior, override `rank_with_weights`.\n\nIt has the `rank-weighted` capability.', params={}, tags={'elicitation', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'RealComparatorNegotiator#1479c080': NegotiatorInfo(key='RealComparatorNegotiator#1479c080', short_name='RealComparatorNegotiator', full_type_name='negmas.negotiators.simple.RealComparatorNegotiator', cls=<class 'negmas.negotiators.simple.RealComparatorNegotiator'>, source='negmas', description='A negotiator that can be asked to evaluate outcomes using its internal ufun.\n\nTh change the way it evaluates outcomes, override `compare_real`\n\nIt has the `compare-real` capability', params={}, tags={'elicitation', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'Rubick#55b74320': NegotiatorInfo(key='Rubick#55b74320', 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', 'anac', 'propose', 'respond'}, extra={}), 'SACRA#7d087b16': NegotiatorInfo(key='SACRA#7d087b16', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'SAGA#49559464': NegotiatorInfo(key='SAGA#49559464', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'SENGOKU#9cc80b1c': NegotiatorInfo(key='SENGOKU#9cc80b1c', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'SMACAgent#371c23fc': NegotiatorInfo(key='SMACAgent#371c23fc', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'SYAgent#4cd70480': NegotiatorInfo(key='SYAgent#4cd70480', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'Seto#e644c036': NegotiatorInfo(key='Seto#e644c036', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'ShahAgent#98969000': NegotiatorInfo(key='ShahAgent#98969000', 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', 'anac', 'propose', 'respond'}, extra={}), 'Shiboy#146850ac': NegotiatorInfo(key='Shiboy#146850ac', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'SimilarityAgent#96b54b17': NegotiatorInfo(key='SimilarityAgent#96b54b17', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'Simpatico#980d0e06': NegotiatorInfo(key='Simpatico#980d0e06', 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', 'anac', 'propose', 'respond'}, extra={}), 'SimpleAgent#7b01ac4d': NegotiatorInfo(key='SimpleAgent#7b01ac4d', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'SimpleAgent2017#7cc7b8b8': NegotiatorInfo(key='SimpleAgent2017#7cc7b8b8', 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', 'anac', 'propose', 'respond'}, extra={}), 'SimpleTitForTatNegotiator#c020edef': NegotiatorInfo(key='SimpleTitForTatNegotiator#c020edef', 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\navailability of an opponent model.\n\nThe negotiator mirrors the opponent\'s concession: if the opponent\'s last\noffer was better for this negotiator than the one before it, the negotiator\nconsiders that the opponent has conceded by the difference and concedes a\nmatching amount (adjusted by ``kindness``). This implicitly assumes a\nzero-sum situation (no opponent model is kept).\n\nArgs:\n    name: Negotiator name.\n    preferences: Negotiator preferences (deprecated; use ``ufun``).\n    ufun: Negotiator utility function (overrides ``preferences``).\n    parent: A controller that manages this negotiator.\n    kindness (float): How \'kind\' the agent is. ``0.0`` is standard\n        tit-for-tat. Positive values make the negotiator concede faster;\n        negative values make it concede slower. Defaults to ``0.0``.\n    stochastic (bool): If ``True``, offers are randomized within the band\n        determined by the current concession (which reflects the\n        opponent\'s concession). If ``False`` (default), the worst outcome\n        in the band is proposed. Defaults to ``False``.\n    punish (bool): If ``True``, the agent punishes a partner who does not\n        concede by requiring higher utilities. Defaults to ``False``.\n    initial_concession (float | str): How much the agent should concede at\n        the beginning, in utility units. Can be a non-negative float or the\n        string ``"min"`` (treated as ``0.0`` — minimum concession).\n        Defaults to ``"min"``.\n    rank_only (bool): If ``True``, only the relative ranks of outcomes (not\n        their actual utilities) are used for inversion. Defaults to ``False``.\n    must_concede (bool): If ``True`` (default) the negotiator is guaranteed\n        to make a (minimal) concession on its second call. Forwarded to\n        `KindConcessionRecommender`.\n    no_concession_step (int): Steps at or below this index get zero\n        concession. Forwarded to `KindConcessionRecommender`.\n    kindness_start_step (int): From this step onward the recommendation is\n        simply the partner\'s concession plus ``kindness``. Forwarded to\n        `KindConcessionRecommender`.\n    min_concession_eps (float): Numerical slack added to the smallest\n        representable utility gap when ``must_concede`` forces a minimal\n        concession. Forwarded to `KindConcessionRecommender`.\n    **kwargs: Forwarded to `MAPNegotiator`.\n\nRemarks:\n    - This negotiator does not keep an opponent model. It thinks only in\n      terms of changes in its own utility. If the opponent\'s last offer\n      was better for the negotiator compared with the one before it, it\n      considers that the opponent has conceded by the difference. This\n      means that it implicitly assumes a zero-sum situation.', params={}, tags={'tit-for-tat', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'SlavaAgent#2318f0a6': NegotiatorInfo(key='SlavaAgent#2318f0a6', 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', 'anac-2013', 'anac', 'propose', 'respond'}, extra={}), 'Sobut#76f4ca75': NegotiatorInfo(key='Sobut#76f4ca75', 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', 'anac', 'propose', 'respond'}, extra={}), 'SolverAgent#55750b6a': NegotiatorInfo(key='SolverAgent#55750b6a', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'Sontag#3f2189d5': NegotiatorInfo(key='Sontag#3f2189d5', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'SorterNegotiator#53704145': NegotiatorInfo(key='SorterNegotiator#53704145', short_name='SorterNegotiator', full_type_name='negmas.negotiators.simple.SorterNegotiator', cls=<class 'negmas.negotiators.simple.SorterNegotiator'>, source='negmas', description='A negotiator that can be asked to rank outcomes returning rank without weight.\nBy default is just consults the ufun.\n\nTo change that behavior, override `sort`.\n\nIt has the `sort` capability.', params={}, tags={'elicitation', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'SouthamptonAgent#c8f61cdb': NegotiatorInfo(key='SouthamptonAgent#c8f61cdb', 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', 'propose', 'respond', 'anac-2010'}, extra={}), 'TMFAgent#3dcd5a81': NegotiatorInfo(key='TMFAgent#3dcd5a81', 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', 'anac-2013', 'anac', 'propose', 'respond'}, extra={}), 'TUDMixedStrategyAgent#5c04a5b8': NegotiatorInfo(key='TUDMixedStrategyAgent#5c04a5b8', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'TUDelftGroup2#6c1ca52b': NegotiatorInfo(key='TUDelftGroup2#6c1ca52b', 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', 'anac', 'propose', 'respond'}, extra={}), 'TaxiBox#2d1d913e': NegotiatorInfo(key='TaxiBox#2d1d913e', 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', 'anac', 'propose', 'respond'}, extra={}), 'Terra#3d97413a': NegotiatorInfo(key='Terra#3d97413a', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'TheFawkes#5350c759': NegotiatorInfo(key='TheFawkes#5350c759', 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', 'anac-2013', 'anac', 'propose', 'respond'}, extra={}), 'TheNegotiator#3b62c103': NegotiatorInfo(key='TheNegotiator#3b62c103', 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', 'anac', 'anac-2011', 'propose', 'respond'}, extra={}), 'TheNegotiatorReloaded#cb28f2e3': NegotiatorInfo(key='TheNegotiatorReloaded#cb28f2e3', 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', 'anac', 'propose', 'respond', 'anac-2012'}, extra={}), 'TheNewDeal#2995a000': NegotiatorInfo(key='TheNewDeal#2995a000', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'TimeBasedConcedingNegotiator#b91d4d0e': NegotiatorInfo(key='TimeBasedConcedingNegotiator#b91d4d0e', short_name='TimeBasedConcedingNegotiator', full_type_name='negmas.gb.negotiators.timebased.TimeBasedConcedingNegotiator', cls=<class 'negmas.gb.negotiators.timebased.TimeBasedConcedingNegotiator'>, source='negmas', description='A time-based conceding negotiator using an `Aspiration` curve.\n\nThis is the main entry point for aspiration-based time-only negotiators.\nIt accepts an `Aspiration` curve (or a string/float shorthand) for both\noffering and accepting, plus a ``starting_utility`` that controls the\nfirst offer\'s utility level.\n\nArgs:\n    offering_curve (Aspiration | str | float): An `Aspiration` curve (or\n        ``"boulware"`` / ``"linear"`` / ``"conceder"`` or a float exponent)\n        controlling how fast the negotiator concedes when offering.\n        Defaults to ``"boulware"`` (slow concession).\n    accepting_curve (Aspiration | str | float | None): An `Aspiration`\n        curve (or string/float) controlling the acceptance threshold. If\n        ``None`` or falsy, the offering curve is reused.\n    starting_utility (float): The relative utility (in ``[0, 1]``) at which\n        the first offer is made. Only used when ``offering_curve`` is a\n        string/float (not a pre-built `Aspiration` object). Defaults to\n        ``1.0`` (start at the best outcome).\n    **kwargs: Forwarded to `TimeBasedNegotiator` (e.g. ``stochastic``,\n        ``ufun_inverter``, ``eps``, ``offer_selector``).\n\nRemarks:\n    - ``BoulwareTBNegotiator``, ``LinearTBNegotiator``, and\n      ``ConcederTBNegotiator`` are convenience subclasses that fix\n      ``offering_curve`` to ``"boulware"``, ``"linear"``, and\n      ``"conceder"`` respectively (with ``stochastic=False``).\n    - `AspirationNegotiator` is a simplified interface to this class with\n      ``presort`` and ``tolerance`` parameters.', params={}, tags={'propose', 'respond', 'time-based', 'builtin', 'sao'}, extra={}), 'TimeBasedNegotiator#a571599b': NegotiatorInfo(key='TimeBasedNegotiator#a571599b', short_name='TimeBasedNegotiator', full_type_name='negmas.gb.negotiators.timebased.TimeBasedNegotiator', cls=<class 'negmas.gb.negotiators.timebased.TimeBasedNegotiator'>, source='negmas', description='A time-based negotiation strategy that concedes independently of the offers\nreceived during the negotiation.\n\nThe negotiator maintains two concession curves: an *offering* curve that\ncontrols the utility range of its own proposals, and an *accepting* curve\nthat controls the utility range of offers it will accept. Both are\n`TimeCurve` objects mapping relative time ``t ∈ [0, 1]`` to a utility\nrange. At each step, the negotiator asks the inverter for an outcome within\nthe offering curve\'s range (for ``propose``) or checks whether the\nopponent\'s offer falls within the accepting curve\'s range (for\n``respond``).\n\nArgs:\n    offering_curve (TimeCurve | str | float): A `TimeCurve` (or a string\n        ``"boulware"`` / ``"linear"`` / ``"conceder"`` or a float exponent)\n        used to sample outcomes when offering. Defaults to ``"boulware"``.\n    accepting_curve (TimeCurve | str | float | None): A `TimeCurve` (or\n        string/float as above) used to decide the utility range to accept.\n        If ``None``, the offering curve is reused (same range for offering\n        and accepting).\n    offer_selector (OfferSelector | None): See `UtilBasedNegotiator`.\n    **kwargs: Forwarded to `UtilBasedNegotiator` (e.g. ``stochastic``,\n        ``ufun_inverter``, ``eps``, ``rank_only``, ``max_cardinality``).\n\nRemarks:\n    - This negotiator is *time-only*: it never reacts to the opponent\'s\n      offers (except accepting/rejecting them). For opponent-aware\n      behavior, use `NaiveTitForTatNegotiator` or the\n      ``OfferOrientedTBNegotiator`` family.', params={}, tags={'propose', 'respond', 'time-based', 'builtin', 'sao'}, extra={}), 'TimeDependentAgentBoulware#13abb184': NegotiatorInfo(key='TimeDependentAgentBoulware#13abb184', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'TimeDependentAgentConceder#1e6b3f0c': NegotiatorInfo(key='TimeDependentAgentConceder#1e6b3f0c', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'TimeDependentAgentHardliner#e1c0ca27': NegotiatorInfo(key='TimeDependentAgentHardliner#e1c0ca27', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'TimeDependentAgentLinear#4c3e728c': NegotiatorInfo(key='TimeDependentAgentLinear#4c3e728c', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'TopFractionNegotiator#3c9b1be1': NegotiatorInfo(key='TopFractionNegotiator#3c9b1be1', short_name='TopFractionNegotiator', full_type_name='negmas.gb.negotiators.tough.TopFractionNegotiator', cls=<class 'negmas.gb.negotiators.tough.TopFractionNegotiator'>, source='negmas', description='Offers and accepts only one of the top outcomes for the negotiator.\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    min_utility: The minimum utility to offer or accept\n    top_fraction: The fraction of the outcomes (ordered decreasingly by utility) to offer or accept\n    best_first: Guarantee offering will non-increasing in terms of utility value\n    probabilistic_offering: Offer randomly from the outcomes selected based on `top_fraction` and `min_utility`\n    owner: The `Agent` that owns the negotiator.', params={}, tags={'utility-based', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'ToughNegotiator#d9224973': NegotiatorInfo(key='ToughNegotiator#d9224973', 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={'aspiration', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'TucAgent#48e07800': NegotiatorInfo(key='TucAgent#48e07800', 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', 'anac', 'propose', 'respond'}, extra={}), 'UtilBasedNegotiator#0c29fef7': NegotiatorInfo(key='UtilBasedNegotiator#0c29fef7', 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\nIt uses an `InverseUFun` (via the `UtilityInverter` component) to find\noutcomes with utilities in a desired range, and an optional `OfferSelector`\nto pick among multiple candidate outcomes.\n\nArgs:\n    stochastic (bool): If ``False`` (default), the inverter's ``worst_in``\n        is used so the negotiator proposes the outcome with the *lowest*\n        utility still within its aspiration band (i.e. just above the\n        aspiration level). If ``True``, ``one_in`` is used so a random\n        in-range outcome is proposed.\n    rank_only (bool): If ``True``, only the relative ranks of outcomes (not\n        their actual utilities) are used for inversion. This maps all\n        equal-utility outcomes to the same rank, which can be useful for\n        non-stationary or noisy ufuns.\n    ufun_inverter (Callable[[BaseUtilityFunction], InverseUFun] | None):\n        A factory that constructs an `InverseUFun` from the negotiator's\n        utility function. If ``None``, a `DefaultInverseUtilityFunction`\n        (i.e. `AdaptiveInverseUtilityFunction`) is used.\n    offer_selector (OfferSelector | None): A callable that selects one\n        outcome from a sequence of candidates given the current state. If\n        ``None`` and ``stochastic`` is ``True``, a random candidate is\n        chosen. If ``None`` and ``stochastic`` is ``False``, ``worst_in``\n        is used directly (no selection needed).\n    max_cardinality (int): The number of outcomes at which the default\n        inverter may switch away from exact presorting to a scalable\n        approximation. Used only if ``ufun_inverter`` is ``None``.\n    eps (float): A tolerance around the utility range used when sampling\n        outcomes (passed to the inverter).\n\nRemarks:\n    - ``propose`` recovers from a ``None`` inverter result (which would\n      otherwise break the SAO mechanism) by falling back to the best\n      outcome. This matters for **strict** inverters (e.g.\n      `BruteForceInverseUtilityFunction`) whose aspiration range contains\n      no outcome, and as a safety net when a clamping inverter's fallbacks\n      are exhausted.", params={}, tags={'utility-based', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'UtilityBasedAcceptor#1651fb34': NegotiatorInfo(key='UtilityBasedAcceptor#1651fb34', 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={'respond', 'genius', 'basic', 'propose'}, extra={}), 'ValueModelAgent#01a67884': NegotiatorInfo(key='ValueModelAgent#01a67884', 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', 'anac', 'anac-2011', 'propose', 'respond'}, extra={}), 'WABNegotiator#d1c9e169': NegotiatorInfo(key='WABNegotiator#d1c9e169', 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={'wab-family', 'learning', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'WANNegotiator#70c29f6b': NegotiatorInfo(key='WANNegotiator#70c29f6b', 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={'wab-family', 'learning', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'WARNegotiator#9f948208': NegotiatorInfo(key='WARNegotiator#9f948208', 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={'wab-family', 'learning', 'propose', 'respond', 'builtin', 'sao'}, extra={}), 'WhaleAgent#755e2187': NegotiatorInfo(key='WhaleAgent#755e2187', 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', 'anac', 'propose', 'respond'}, extra={}), 'WinkyAgent#ddda44cd': NegotiatorInfo(key='WinkyAgent#ddda44cd', 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', 'propose', 'respond', 'anac-2019'}, extra={}), 'XianFaAgent#848ee301': NegotiatorInfo(key='XianFaAgent#848ee301', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'Y2015Group2#b564a9b8': NegotiatorInfo(key='Y2015Group2#b564a9b8', 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', 'anac-2015', 'anac', 'propose', 'respond'}, extra={}), 'YXAgent#dff93728': NegotiatorInfo(key='YXAgent#dff93728', 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', 'anac', 'propose', 'respond', 'anac-2016'}, extra={}), 'Yeela#6901fb81': NegotiatorInfo(key='Yeela#6901fb81', 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', 'anac', 'propose', 'respond', 'anac-2018'}, extra={}), 'Yushu#1affb654': NegotiatorInfo(key='Yushu#1affb654', 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', 'propose', 'respond', 'anac-2010'}, 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/latest/src/negmas/scenarios/CameraB': ScenarioInfo(name='CameraB', path=PosixPath('/home/docs/checkouts/readthedocs.org/user_builds/negmas/checkouts/latest/src/negmas/scenarios/CameraB'), source='negmas', description='', tags={'xml', 'builtin', 'bilateral'}, n_outcomes=3600, n_negotiators=2, opposition_level=0.247616, rational_fraction=None, read_only=True, extra={})}

The global scenario registry.