Skip to content

Wrapper Classes

All wrapper classes inherit from NegologNegotiatorWrapper and can be used as NegMAS SAONegotiator instances.

Time-Based Agents

BoulwareAgent

negmas_negolog.BoulwareAgent

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's BoulwareAgent.

A "tough" time-based concession agent that concedes slowly (sub-linearly) over the negotiation deadline. Named after the negotiation tactic of being "hard-headed" early and only conceding near the deadline.

Offering Strategy: Uses a quadratic Bézier curve to calculate target utility over time:

\[TU = (1-t)^2 P_0 + 2(1-t)t P_1 + t^2 P_2\]

where t is normalized time [0,1], P0=1.0 (initial utility), P1=0.85 (control point), and P2=0.4 (final utility). The high P1 value (P1 >= (P0+P2)/2) creates a concave curve that maintains high utility demands until late in the negotiation.

Acceptance Strategy: Uses AC_Next: accepts if the opponent's last offer provides utility greater than or equal to the agent's current target utility.

Opponent Modeling: None. This is a pure time-based strategy that ignores opponent behavior.

References

.. [Faratin1998] Peyman Faratin, Carles Sierra, and Nick R. Jennings. "Negotiation decision functions for autonomous agents." Robotics and Autonomous Systems 24, 3 (1998), 159-182.

.. [Vahidov2017] Rustam M. Vahidov, Gregory E. Kersten, and Bo Yu. "Human-Agent Negotiations: The Impact Agents' Concession Schedule and Task Complexity on Agreements." HICSS 2017.

See Also

Paper: https://doi.org/10.1016/S0921-8890(98)00023-6

Note

This description was AI-generated based on the referenced papers and source code analysis.

Source code in src/negmas_negolog/agents/boulware.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
class BoulwareAgent(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's BoulwareAgent.

    A "tough" time-based concession agent that concedes slowly (sub-linearly)
    over the negotiation deadline. Named after the negotiation tactic of being
    "hard-headed" early and only conceding near the deadline.

    **Offering Strategy:**
    Uses a quadratic Bézier curve to calculate target utility over time:

    $$TU = (1-t)^2 P_0 + 2(1-t)t P_1 + t^2 P_2$$

    where t is normalized time [0,1], P0=1.0 (initial utility),
    P1=0.85 (control point), and P2=0.4 (final utility). The high P1 value
    (P1 >= (P0+P2)/2) creates a concave curve that maintains high utility
    demands until late in the negotiation.

    **Acceptance Strategy:**
    Uses AC_Next: accepts if the opponent's last offer provides utility
    greater than or equal to the agent's current target utility.

    **Opponent Modeling:**
    None. This is a pure time-based strategy that ignores opponent behavior.

    References:
        .. [Faratin1998] Peyman Faratin, Carles Sierra, and Nick R. Jennings.
           "Negotiation decision functions for autonomous agents."
           Robotics and Autonomous Systems 24, 3 (1998), 159-182.

        .. [Vahidov2017] Rustam M. Vahidov, Gregory E. Kersten, and Bo Yu.
           "Human-Agent Negotiations: The Impact Agents' Concession Schedule
           and Task Complexity on Agreements." HICSS 2017.

    See Also:
        Paper: https://doi.org/10.1016/S0921-8890(98)00023-6

    Note:
        This description was AI-generated based on the referenced papers
        and source code analysis.
    """

    negolog_agent_class = _NLBoulwareAgent

ConcederAgent

negmas_negolog.ConcederAgent

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's ConcederAgent.

A "soft" time-based concession agent that concedes quickly (super-linearly) over the negotiation deadline. Useful when reaching agreement is more important than maximizing utility.

Offering Strategy: Uses a quadratic Bézier curve to calculate target utility over time:

\[TU = (1-t)^2 P_0 + 2(1-t)t P_1 + t^2 P_2\]

where t is normalized time [0,1], P0=1.0 (initial utility), P1=0.55 (control point), and P2=0.4 (final utility). The low P1 value (P1 <= (P0+P2)/2) creates a convex curve that concedes quickly early in the negotiation.

Acceptance Strategy: Uses AC_Next: accepts if the opponent's last offer provides utility greater than or equal to the agent's current target utility.

Opponent Modeling: None. This is a pure time-based strategy that ignores opponent behavior.

References

.. [Faratin1998] Peyman Faratin, Carles Sierra, and Nick R. Jennings. "Negotiation decision functions for autonomous agents." Robotics and Autonomous Systems 24, 3 (1998), 159-182.

.. [Vahidov2017] Rustam M. Vahidov, Gregory E. Kersten, and Bo Yu. "Human-Agent Negotiations: The Impact Agents' Concession Schedule and Task Complexity on Agreements." HICSS 2017.

See Also

Paper: https://doi.org/10.1016/S0921-8890(98)00023-6

Note

This description was AI-generated based on the referenced papers and source code analysis.

Source code in src/negmas_negolog/agents/conceder.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
class ConcederAgent(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's ConcederAgent.

    A "soft" time-based concession agent that concedes quickly (super-linearly)
    over the negotiation deadline. Useful when reaching agreement is more
    important than maximizing utility.

    **Offering Strategy:**
    Uses a quadratic Bézier curve to calculate target utility over time:

    $$TU = (1-t)^2 P_0 + 2(1-t)t P_1 + t^2 P_2$$

    where t is normalized time [0,1], P0=1.0 (initial utility),
    P1=0.55 (control point), and P2=0.4 (final utility). The low P1 value
    (P1 <= (P0+P2)/2) creates a convex curve that concedes quickly early
    in the negotiation.

    **Acceptance Strategy:**
    Uses AC_Next: accepts if the opponent's last offer provides utility
    greater than or equal to the agent's current target utility.

    **Opponent Modeling:**
    None. This is a pure time-based strategy that ignores opponent behavior.

    References:
        .. [Faratin1998] Peyman Faratin, Carles Sierra, and Nick R. Jennings.
           "Negotiation decision functions for autonomous agents."
           Robotics and Autonomous Systems 24, 3 (1998), 159-182.

        .. [Vahidov2017] Rustam M. Vahidov, Gregory E. Kersten, and Bo Yu.
           "Human-Agent Negotiations: The Impact Agents' Concession Schedule
           and Task Complexity on Agreements." HICSS 2017.

    See Also:
        Paper: https://doi.org/10.1016/S0921-8890(98)00023-6

    Note:
        This description was AI-generated based on the referenced papers
        and source code analysis.
    """

    negolog_agent_class = _NLConcederAgent

LinearAgent

negmas_negolog.LinearAgent

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's LinearAgent.

A balanced time-based concession agent that concedes linearly over the negotiation deadline. Provides a middle ground between the aggressive Boulware and cooperative Conceder strategies.

Offering Strategy: Uses a quadratic Bézier curve to calculate target utility over time:

\[TU = (1-t)^2 P_0 + 2(1-t)t P_1 + t^2 P_2\]

where t is normalized time [0,1], P0=1.0 (initial utility), P1=0.7 (control point), and P2=0.4 (final utility). The P1 value is set to (P0+P2)/2, creating a straight line from initial to final utility.

Acceptance Strategy: Uses AC_Next: accepts if the opponent's last offer provides utility greater than or equal to the agent's current target utility.

Opponent Modeling: None. This is a pure time-based strategy that ignores opponent behavior.

References

.. [Faratin1998] Peyman Faratin, Carles Sierra, and Nick R. Jennings. "Negotiation decision functions for autonomous agents." Robotics and Autonomous Systems 24, 3 (1998), 159-182.

.. [Vahidov2017] Rustam M. Vahidov, Gregory E. Kersten, and Bo Yu. "Human-Agent Negotiations: The Impact Agents' Concession Schedule and Task Complexity on Agreements." HICSS 2017.

See Also

Paper: https://doi.org/10.1016/S0921-8890(98)00023-6

Note

This description was AI-generated based on the referenced papers and source code analysis.

Source code in src/negmas_negolog/agents/linear.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
class LinearAgent(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's LinearAgent.

    A balanced time-based concession agent that concedes linearly over the
    negotiation deadline. Provides a middle ground between the aggressive
    Boulware and cooperative Conceder strategies.

    **Offering Strategy:**
    Uses a quadratic Bézier curve to calculate target utility over time:

    $$TU = (1-t)^2 P_0 + 2(1-t)t P_1 + t^2 P_2$$

    where t is normalized time [0,1], P0=1.0 (initial utility),
    P1=0.7 (control point), and P2=0.4 (final utility). The P1 value
    is set to (P0+P2)/2, creating a straight line from initial to final
    utility.

    **Acceptance Strategy:**
    Uses AC_Next: accepts if the opponent's last offer provides utility
    greater than or equal to the agent's current target utility.

    **Opponent Modeling:**
    None. This is a pure time-based strategy that ignores opponent behavior.

    References:
        .. [Faratin1998] Peyman Faratin, Carles Sierra, and Nick R. Jennings.
           "Negotiation decision functions for autonomous agents."
           Robotics and Autonomous Systems 24, 3 (1998), 159-182.

        .. [Vahidov2017] Rustam M. Vahidov, Gregory E. Kersten, and Bo Yu.
           "Human-Agent Negotiations: The Impact Agents' Concession Schedule
           and Task Complexity on Agreements." HICSS 2017.

    See Also:
        Paper: https://doi.org/10.1016/S0921-8890(98)00023-6

    Note:
        This description was AI-generated based on the referenced papers
        and source code analysis.
    """

    negolog_agent_class = _NLLinearAgent

Competition Agents

Atlas3Agent

negmas_negolog.Atlas3Agent

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's Atlas3Agent.

ANAC 2015 Winner (Individual Utility & Nash Product categories).

Atlas3 is a sophisticated negotiation agent developed by Akiyuki Mori that uses adaptive strategies based on opponent behavior analysis and game-theoretic concepts.

Offering Strategy: - Uses appropriate bid searching based on relative utility for linear utility spaces - Applies replacement method based on frequency analysis of opponent's bidding history - Concession function derived from Evolutionary Stable Strategy (ESS) expected utility analysis - Near deadline: cycles through promising bids from opponent's history

Acceptance Strategy: - Accepts if the offer utility exceeds the current threshold calculated from ESS-based concession function - Near deadline: accepts bids above reservation value from candidate list

Opponent Modeling: Frequency-based model that tracks opponent's bidding patterns to: - Estimate opponent preferences - Identify promising bids that might be acceptable to both parties - Guide bid search towards mutually beneficial outcomes

References

.. [Mori2017] Mori, A., Ito, T. (2017). Atlas3: A Negotiating Agent Based on Expecting Lower Limit of Concession Function. In: Modern Approaches to Agent-based Complex Automated Negotiation. Studies in Computational Intelligence, vol 674. Springer, Cham.

.. [Mori2015] Mori, A., & Ito, T. (2015). A compromising strategy based on expected utility of evolutionary stable strategy in bilateral closed bargaining problem. ACAN 2015.

See Also

Paper: https://doi.org/10.1007/978-3-319-51563-2_11

Note

This description was AI-generated based on the referenced papers and source code analysis.

Source code in src/negmas_negolog/agents/atlas3.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class Atlas3Agent(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's Atlas3Agent.

    **ANAC 2015 Winner** (Individual Utility & Nash Product categories).

    Atlas3 is a sophisticated negotiation agent developed by Akiyuki Mori that
    uses adaptive strategies based on opponent behavior analysis and game-theoretic
    concepts.

    **Offering Strategy:**
        - Uses appropriate bid searching based on relative utility for linear
          utility spaces
        - Applies replacement method based on frequency analysis of opponent's
          bidding history
        - Concession function derived from Evolutionary Stable Strategy (ESS)
          expected utility analysis
        - Near deadline: cycles through promising bids from opponent's history

    **Acceptance Strategy:**
        - Accepts if the offer utility exceeds the current threshold calculated
          from ESS-based concession function
        - Near deadline: accepts bids above reservation value from candidate list

    **Opponent Modeling:**
        Frequency-based model that tracks opponent's bidding patterns to:
        - Estimate opponent preferences
        - Identify promising bids that might be acceptable to both parties
        - Guide bid search towards mutually beneficial outcomes

    References:
        .. [Mori2017] Mori, A., Ito, T. (2017). Atlas3: A Negotiating Agent Based
           on Expecting Lower Limit of Concession Function. In: Modern Approaches
           to Agent-based Complex Automated Negotiation. Studies in Computational
           Intelligence, vol 674. Springer, Cham.

        .. [Mori2015] Mori, A., & Ito, T. (2015). A compromising strategy based on
           expected utility of evolutionary stable strategy in bilateral closed
           bargaining problem. ACAN 2015.

    See Also:
        Paper: https://doi.org/10.1007/978-3-319-51563-2_11

    Note:
        This description was AI-generated based on the referenced papers
        and source code analysis.
    """

    negolog_agent_class = _NLAtlas3Agent

HardHeaded

negmas_negolog.HardHeaded

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's HardHeaded agent.

ANAC 2011 Winner (Individual Utility category).

As the name implies, HardHeaded (developed by Thijs van Krimpen) is an aggressive negotiator that maintains high demands throughout most of the negotiation and only concedes near the deadline.

Offering Strategy: - Uses a monotonic concession function that generates bids in decreasing utility order - Cycles through the same range of high-utility bids for most of the negotiation - Resets to a random bid after reaching the dynamic concession limit - Selects bids that maximize estimated opponent utility among equivalent bids for itself

Acceptance Strategy: - Accepts if opponent's offer exceeds the lowest utility offered so far - Accepts if opponent's offer is better than the next planned offer - Very conservative early acceptance thresholds

Opponent Modeling: Frequency-based learning approach: - Tracks unchanged issues between consecutive opponent bids to estimate issue weights - Counts value frequencies to estimate value utilities - Uses learned model to select bids favorable to opponent among equivalent options

References

.. [Krimpen2013] van Krimpen, T., Looije, D., Hajizadeh, S. (2013). HardHeaded. In: Complex Automated Negotiations: Theories, Models, and Software Competitions. Studies in Computational Intelligence, vol 435. Springer, Berlin, Heidelberg.

See Also

Paper: https://doi.org/10.1007/978-3-642-30737-9_17

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/hardheaded.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
class HardHeaded(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's HardHeaded agent.

    **ANAC 2011 Winner** (Individual Utility category).

    As the name implies, HardHeaded (developed by Thijs van Krimpen) is an
    aggressive negotiator that maintains high demands throughout most of the
    negotiation and only concedes near the deadline.

    **Offering Strategy:**
        - Uses a monotonic concession function that generates bids in decreasing
          utility order
        - Cycles through the same range of high-utility bids for most of the
          negotiation
        - Resets to a random bid after reaching the dynamic concession limit
        - Selects bids that maximize estimated opponent utility among equivalent
          bids for itself

    **Acceptance Strategy:**
        - Accepts if opponent's offer exceeds the lowest utility offered so far
        - Accepts if opponent's offer is better than the next planned offer
        - Very conservative early acceptance thresholds

    **Opponent Modeling:**
        Frequency-based learning approach:
        - Tracks unchanged issues between consecutive opponent bids to estimate
          issue weights
        - Counts value frequencies to estimate value utilities
        - Uses learned model to select bids favorable to opponent among
          equivalent options

    References:
        .. [Krimpen2013] van Krimpen, T., Looije, D., Hajizadeh, S. (2013).
           HardHeaded. In: Complex Automated Negotiations: Theories, Models,
           and Software Competitions. Studies in Computational Intelligence,
           vol 435. Springer, Berlin, Heidelberg.

    See Also:
        Paper: https://doi.org/10.1007/978-3-642-30737-9_17

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLHardHeaded

NiceTitForTat

negmas_negolog.NiceTitForTat

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's NiceTitForTat agent.

NiceTitForTat (developed by Tim Baarslag) implements a cooperative tit-for-tat strategy with respect to utility space, aiming for the Nash bargaining solution.

Offering Strategy: - Initially cooperates with high utility bids - Responds in kind to opponent's concessions - Calculates opponent's concession factor relative to Nash point - Mirrors opponent's concession proportionally - Time bonus near deadline to encourage agreement - Selects bids that maximize opponent utility among equivalents

Acceptance Strategy: - Accepts if opponent's offer >= planned counter-offer utility - Near deadline: probabilistic acceptance based on expected utility of waiting for better offers - Considers recent bid history to estimate probability of improvement

Opponent Modeling: Bayesian opponent model that: - Updates beliefs about opponent preferences after each bid - Estimates opponent's utility function - Used to find Nash point and select opponent-favorable bids - Guides concession strategy to match opponent's behavior

References

.. [Baarslag2013] Tim Baarslag, Koen Hindriks, and Catholijn Jonker. "A tit for tat negotiation strategy for real-time bilateral negotiations." Studies in Computational Intelligence, 435:229-233, 2013.

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/nice_tit_for_tat.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
class NiceTitForTat(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's NiceTitForTat agent.

    NiceTitForTat (developed by Tim Baarslag) implements a cooperative
    tit-for-tat strategy with respect to utility space, aiming for the
    Nash bargaining solution.

    **Offering Strategy:**
        - Initially cooperates with high utility bids
        - Responds in kind to opponent's concessions
        - Calculates opponent's concession factor relative to Nash point
        - Mirrors opponent's concession proportionally
        - Time bonus near deadline to encourage agreement
        - Selects bids that maximize opponent utility among equivalents

    **Acceptance Strategy:**
        - Accepts if opponent's offer >= planned counter-offer utility
        - Near deadline: probabilistic acceptance based on expected utility
          of waiting for better offers
        - Considers recent bid history to estimate probability of improvement

    **Opponent Modeling:**
        Bayesian opponent model that:
        - Updates beliefs about opponent preferences after each bid
        - Estimates opponent's utility function
        - Used to find Nash point and select opponent-favorable bids
        - Guides concession strategy to match opponent's behavior

    References:
        .. [Baarslag2013] Tim Baarslag, Koen Hindriks, and Catholijn Jonker.
           "A tit for tat negotiation strategy for real-time bilateral
           negotiations." Studies in Computational Intelligence, 435:229-233,
           2013.

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLNiceTitForTat

AgentGG

negmas_negolog.AgentGG

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's AgentGG.

ANAC 2019 Winner (Individual Utility category).

AgentGG (developed by Shaobo Xu) uses importance maps (a frequentist approach) to estimate both self and opponent preferences, focusing on bid importance rather than raw utility values.

Offering Strategy: - Time-based concession with importance thresholds - Early phase (t < 0.2): random bid selection within threshold - Middle phase: selects bids maximizing estimated opponent importance - Thresholds decrease over time based on estimated Nash point - Uses importance maps instead of utility for bid evaluation

Acceptance Strategy: - Accepts if received bid's importance ratio exceeds current threshold - Near deadline (t >= 0.9989): accepts if importance exceeds reservation + 0.2 - Thresholds adapt based on estimated Nash point

Opponent Modeling: Frequentist importance maps that estimate: - Self preferences from own utility function analysis - Opponent preferences from their bidding patterns - Uses estimated opponent importance to select favorable bids - Updates opponent model during early negotiation (t < 0.3)

References

.. [Aydogan2020] Aydogan, R. et al. (2020). Challenges and Main Results of the Automated Negotiating Agents Competition (ANAC) 2019. In: Multi-Agent Systems and Agreement Technologies. EUMAS AT 2020. Lecture Notes in Computer Science, vol 12520. Springer, Cham.

See Also

Paper: https://doi.org/10.1007/978-3-030-66412-1_23

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/agent_gg.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
class AgentGG(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's AgentGG.

    **ANAC 2019 Winner** (Individual Utility category).

    AgentGG (developed by Shaobo Xu) uses importance maps (a frequentist
    approach) to estimate both self and opponent preferences, focusing on
    bid importance rather than raw utility values.

    **Offering Strategy:**
        - Time-based concession with importance thresholds
        - Early phase (t < 0.2): random bid selection within threshold
        - Middle phase: selects bids maximizing estimated opponent importance
        - Thresholds decrease over time based on estimated Nash point
        - Uses importance maps instead of utility for bid evaluation

    **Acceptance Strategy:**
        - Accepts if received bid's importance ratio exceeds current threshold
        - Near deadline (t >= 0.9989): accepts if importance exceeds
          reservation + 0.2
        - Thresholds adapt based on estimated Nash point

    **Opponent Modeling:**
        Frequentist importance maps that estimate:
        - Self preferences from own utility function analysis
        - Opponent preferences from their bidding patterns
        - Uses estimated opponent importance to select favorable bids
        - Updates opponent model during early negotiation (t < 0.3)

    References:
        .. [Aydogan2020] Aydogan, R. et al. (2020). Challenges and Main Results
           of the Automated Negotiating Agents Competition (ANAC) 2019.
           In: Multi-Agent Systems and Agreement Technologies. EUMAS AT 2020.
           Lecture Notes in Computer Science, vol 12520. Springer, Cham.

    See Also:
        Paper: https://doi.org/10.1007/978-3-030-66412-1_23

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLAgentGG

SAGAAgent

negmas_negolog.SAGAAgent

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's SAGAAgent.

ANAC 2019 Individual Utility Category Finalist.

SAGA (Simulated Annealing Genetic Algorithm) Agent by Yuta Hosokawa applies a Genetic Algorithm approach to estimate its own preferences (using Spearman correlation as the fitness function) combined with time-based bidding and acceptance strategies.

Offering Strategy: Uses a time-dependent target utility function:

\[target(t) = target_{min} + (1 - target_{min}) \cdot (1 - t^5)\]

where target_min is derived from the utility of the first received bid: target_min = firstUtil + 0.6 * (1 - firstUtil).

Bids are randomly generated above the target utility threshold.

Acceptance Strategy: Employs a three-phase probabilistic acceptance strategy:

  • Phase 1 (t <= 0.6): Probabilistic acceptance based on how much the offer exceeds the target. Uses power function with exponent that increases as time approaches 0.5.
  • Phase 2 (0.6 < t < 0.997): Gradually increasing acceptance probability for bids below target, with linear interpolation.
  • Phase 3 (t >= 0.997): Near deadline, accepts with probability proportional to utility squared.

Always rejects offers below reservation value.

Opponent Modeling: SAGA Agent was designed to use Genetic Algorithm to estimate preferences, though the current implementation uses actual preferences. The GA approach uses Spearman rank correlation as the fitness metric to evaluate preference estimation quality.

References

.. [Aydogan2020] Aydogan, R. et al. (2020). Challenges and Main Results of the Automated Negotiating Agents Competition (ANAC) 2019. In: Bassiliades, N., Chalkiadakis, G., de Jonge, D. (eds) Multi-Agent Systems and Agreement Technologies. EUMAS AT 2020. Lecture Notes in Computer Science, vol 12520. Springer, Cham.

See Also

Paper: https://doi.org/10.1007/978-3-030-66412-1_23

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/saga.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
class SAGAAgent(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's SAGAAgent.

    **ANAC 2019 Individual Utility Category Finalist**.

    SAGA (Simulated Annealing Genetic Algorithm) Agent by Yuta Hosokawa
    applies a Genetic Algorithm approach to estimate its own preferences
    (using Spearman correlation as the fitness function) combined with
    time-based bidding and acceptance strategies.

    **Offering Strategy:**
    Uses a time-dependent target utility function:

    $$target(t) = target_{min} + (1 - target_{min}) \cdot (1 - t^5)$$

    where target_min is derived from the utility of the first received
    bid: target_min = firstUtil + 0.6 * (1 - firstUtil).

    Bids are randomly generated above the target utility threshold.

    **Acceptance Strategy:**
    Employs a three-phase probabilistic acceptance strategy:

    - **Phase 1 (t <= 0.6)**: Probabilistic acceptance based on how much
      the offer exceeds the target. Uses power function with exponent
      that increases as time approaches 0.5.
    - **Phase 2 (0.6 < t < 0.997)**: Gradually increasing acceptance
      probability for bids below target, with linear interpolation.
    - **Phase 3 (t >= 0.997)**: Near deadline, accepts with probability
      proportional to utility squared.

    Always rejects offers below reservation value.

    **Opponent Modeling:**
    SAGA Agent was designed to use Genetic Algorithm to estimate
    preferences, though the current implementation uses actual
    preferences. The GA approach uses Spearman rank correlation as
    the fitness metric to evaluate preference estimation quality.

    References:
        .. [Aydogan2020] Aydogan, R. et al. (2020). Challenges and Main
           Results of the Automated Negotiating Agents Competition (ANAC)
           2019. In: Bassiliades, N., Chalkiadakis, G., de Jonge, D. (eds)
           Multi-Agent Systems and Agreement Technologies. EUMAS AT 2020.
           Lecture Notes in Computer Science, vol 12520. Springer, Cham.

    See Also:
        Paper: https://doi.org/10.1007/978-3-030-66412-1_23

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLSAGAAgent

MICROAgent

negmas_negolog.MICROAgent

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's MICROAgent.

ANAC 2022 Runner-up (Individual Utility category).

MiCRO (Monotonic Concession with Reciprocal Offers, developed by Dave de Jonge) is a benchmark strategy that only concedes when the opponent demonstrates willingness to concede through unique bid proposals.

Offering Strategy: - Starts with the highest utility bid - Concedes only when opponent has made at least as many unique bids as the agent - When conceding, moves to the next lower utility bid - Checks if opponent has proposed any bid with equal utility and prefers to offer those (reciprocity) - Between concessions, randomly selects from previously offered bids

Acceptance Strategy: - Uses AC_Next: accepts if opponent's last offer provides utility greater than or equal to the agent's planned next bid - Also requires offer to meet reservation value

Opponent Modeling: Simple reciprocity-based tracking: - Counts unique bids received from opponent - Uses this count to determine when to concede (tit-for-tat style) - Checks if opponent has proposed equivalent-utility bids for preferential selection

References

.. [deJonge2022] Dave de Jonge. "An analysis of the linear bilateral ANAC domains using the MiCRO benchmark strategy." IJCAI 2022, Vienna, Austria, pp. 223-229.

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/micro.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
class MICROAgent(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's MICROAgent.

    **ANAC 2022 Runner-up** (Individual Utility category).

    MiCRO (Monotonic Concession with Reciprocal Offers, developed by Dave de
    Jonge) is a benchmark strategy that only concedes when the opponent
    demonstrates willingness to concede through unique bid proposals.

    **Offering Strategy:**
        - Starts with the highest utility bid
        - Concedes only when opponent has made at least as many unique bids
          as the agent
        - When conceding, moves to the next lower utility bid
        - Checks if opponent has proposed any bid with equal utility and
          prefers to offer those (reciprocity)
        - Between concessions, randomly selects from previously offered bids

    **Acceptance Strategy:**
        - Uses AC_Next: accepts if opponent's last offer provides utility
          greater than or equal to the agent's planned next bid
        - Also requires offer to meet reservation value

    **Opponent Modeling:**
        Simple reciprocity-based tracking:
        - Counts unique bids received from opponent
        - Uses this count to determine when to concede (tit-for-tat style)
        - Checks if opponent has proposed equivalent-utility bids for
          preferential selection

    References:
        .. [deJonge2022] Dave de Jonge. "An analysis of the linear bilateral
           ANAC domains using the MiCRO benchmark strategy." IJCAI 2022,
           Vienna, Austria, pp. 223-229.

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLMICROAgent

CUHKAgent

negmas_negolog.CUHKAgent

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's CUHKAgent.

ANAC 2012 Winner.

CUHKAgent (developed at Chinese University of Hong Kong by Jianye Hao) is an adaptive negotiation agent that adjusts its strategy based on opponent behavior and time pressure.

Offering Strategy: - Time-dependent concession with adaptive threshold adjustment - Concession rate adapts based on opponent's toughness degree - In large domains: focuses on high-utility bid range - Near deadline: considers opponent's best offer as fallback - Uses opponent model to select bids favorable to opponent among candidates

Acceptance Strategy: - Accepts if offer exceeds current utility threshold - Accepts if offer exceeds the utility of planned counter-offer - Near deadline: more lenient acceptance based on opponent's best offer - Adapts acceptance based on predicted maximum achievable utility

Opponent Modeling: - Tracks opponent's bidding history to estimate preferences - Calculates opponent's concession degree to adapt own strategy - Identifies opponent's maximum offered bid for reference - Uses opponent model to choose mutually beneficial bids

References

.. [Hao2014] Hao, J., Leung, Hf. (2014). CUHKAgent: An Adaptive Negotiation Strategy for Bilateral Negotiations over Multiple Items. In: Novel Insights in Agent-based Complex Automated Negotiation. Studies in Computational Intelligence, vol 535. Springer, Tokyo.

See Also

Paper: https://doi.org/10.1007/978-4-431-54758-7_11

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/cuhk.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
class CUHKAgent(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's CUHKAgent.

    **ANAC 2012 Winner**.

    CUHKAgent (developed at Chinese University of Hong Kong by Jianye Hao)
    is an adaptive negotiation agent that adjusts its strategy based on
    opponent behavior and time pressure.

    **Offering Strategy:**
        - Time-dependent concession with adaptive threshold adjustment
        - Concession rate adapts based on opponent's toughness degree
        - In large domains: focuses on high-utility bid range
        - Near deadline: considers opponent's best offer as fallback
        - Uses opponent model to select bids favorable to opponent among
          candidates

    **Acceptance Strategy:**
        - Accepts if offer exceeds current utility threshold
        - Accepts if offer exceeds the utility of planned counter-offer
        - Near deadline: more lenient acceptance based on opponent's best offer
        - Adapts acceptance based on predicted maximum achievable utility

    **Opponent Modeling:**
        - Tracks opponent's bidding history to estimate preferences
        - Calculates opponent's concession degree to adapt own strategy
        - Identifies opponent's maximum offered bid for reference
        - Uses opponent model to choose mutually beneficial bids

    References:
        .. [Hao2014] Hao, J., Leung, Hf. (2014). CUHKAgent: An Adaptive
           Negotiation Strategy for Bilateral Negotiations over Multiple Items.
           In: Novel Insights in Agent-based Complex Automated Negotiation.
           Studies in Computational Intelligence, vol 535. Springer, Tokyo.

    See Also:
        Paper: https://doi.org/10.1007/978-4-431-54758-7_11

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLCUHKAgent

AgentKN

negmas_negolog.AgentKN

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's AgentKN.

ANAC 2017 Nash Product Category Finalist.

AgentKN by Keita Nakamura uses Simulated Annealing for bid search and a sophisticated opponent modeling approach to estimate the maximum utility the opponent might offer. It balances self-utility maximization with opponent value frequency analysis.

Offering Strategy: Uses Simulated Annealing to search for 10 bids that maximize utility while starting from a random initial bid. The bids are then scored using a combined metric:

\[score = utility + 0.1^{(\log_{10}(frequency)+1)} \cdot frequency \cdot utility\]

where frequency is the sum of opponent-offered value frequencies. This encourages bids that are both high-utility and contain values the opponent has frequently requested.

Acceptance Strategy: Accepts when the opponent's bid exceeds a dynamic threshold:

\[threshold(t) = 1 - (1 - e_{max}(t)) \cdot t^lpha\]

where alpha > 1 controls concession rate and e_max(t) is the estimated maximum utility the opponent might offer, calculated as:

\[e_{max}(t) = \mu(t) + (1 - \mu(t)) \cdot d(t)\]
\[d(t) = rac{\sqrt{3} \cdot \sigma(t)}{\sqrt{\mu(t) \cdot (1 - \mu(t))}}\]

where mu(t) is the mean and sigma(t) is the standard deviation of utilities from opponent offers.

Opponent Modeling: Tracks value frequencies for each issue across opponent bids:

  • Updates issue weights when consecutive bids have the same value
  • Maintains normalized value frequency counts per issue
  • Uses statistical analysis (mean, std) of opponent bid utilities to estimate the opponent's bidding range
References

.. [Aydogan2021] Reyhan Aydogan, Katsuhide Fujita, Tim Baarslag, Catholijn M. Jonker, and Takayuki Ito. ANAC 2017: Repeated multilateral negotiation league. In Advances in Automated Negotiations, pages 101-115, Singapore, 2021. Springer Singapore.

See Also

Paper: https://doi.org/10.1007/978-981-16-0471-3_7

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/agent_kn.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
class AgentKN(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's AgentKN.

    **ANAC 2017 Nash Product Category Finalist**.

    AgentKN by Keita Nakamura uses Simulated Annealing for bid search and
    a sophisticated opponent modeling approach to estimate the maximum
    utility the opponent might offer. It balances self-utility maximization
    with opponent value frequency analysis.

    **Offering Strategy:**
    Uses Simulated Annealing to search for 10 bids that maximize utility
    while starting from a random initial bid. The bids are then scored
    using a combined metric:

    $$score = utility + 0.1^{(\log_{10}(frequency)+1)} \cdot frequency \cdot utility$$

    where frequency is the sum of opponent-offered value frequencies.
    This encourages bids that are both high-utility and contain values
    the opponent has frequently requested.

    **Acceptance Strategy:**
    Accepts when the opponent's bid exceeds a dynamic threshold:

    $$threshold(t) = 1 - (1 - e_{max}(t)) \cdot t^\alpha$$

    where alpha > 1 controls concession rate and e_max(t) is the
    estimated maximum utility the opponent might offer, calculated as:

    $$e_{max}(t) = \mu(t) + (1 - \mu(t)) \cdot d(t)$$

    $$d(t) = \frac{\sqrt{3} \cdot \sigma(t)}{\sqrt{\mu(t) \cdot (1 - \mu(t))}}$$

    where mu(t) is the mean and sigma(t) is the standard deviation of
    utilities from opponent offers.

    **Opponent Modeling:**
    Tracks value frequencies for each issue across opponent bids:

    - Updates issue weights when consecutive bids have the same value
    - Maintains normalized value frequency counts per issue
    - Uses statistical analysis (mean, std) of opponent bid utilities
      to estimate the opponent's bidding range

    References:
        .. [Aydogan2021] Reyhan Aydogan, Katsuhide Fujita, Tim Baarslag,
           Catholijn M. Jonker, and Takayuki Ito. ANAC 2017: Repeated
           multilateral negotiation league. In Advances in Automated
           Negotiations, pages 101-115, Singapore, 2021. Springer Singapore.

    See Also:
        Paper: https://doi.org/10.1007/978-981-16-0471-3_7

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLAgentKN

Rubick

negmas_negolog.Rubick

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's Rubick agent.

ANAC 2017 Individual Utility Category Finalist.

Rubick Agent by Okan Tunali is a complex time-based conceder enriched with frequency-based opponent modeling. It maintains the highest utility ever received as a lower bound and uses randomized Boulware-style concession with increasing variance over time.

Offering Strategy: Generates bids above a target utility using opponent model insights:

  • Searches for bids that maximize intersection with opponent's most frequently offered values (frequency-based search)
  • If no suitable bid found via opponent model, falls back to nearest bid to target utility
  • Near deadline (t > 0.995), offers from a cached list of previously accepted bids

Target utility follows randomized Boulware with power parameter randomly selected based on max received utility.

Acceptance Strategy: Time-based with randomness to prevent exploitation:

\[target = 1 - t^{power} \cdot |\mathcal{N}(0, 1/3)|\]

where power is randomly 2, 3, or 10 based on opponent behavior. The target is bounded by the maximum received utility. Accepts if opponent offer exceeds target or time > 0.999.

Opponent Modeling: Employs frequency-based opponent modeling:

  • Tracks value frequencies for each issue per opponent
  • Extracts "bags" of preferred values (above median frequency)
  • Scores bids by counting intersections with opponent preferences
  • Maintains separate models for multilateral scenarios

Also keeps a sorted list of bids that were accepted by opponents in previous negotiations for use near the deadline.

References

.. [Aydogan2021] Reyhan Aydogan, Katsuhide Fujita, Tim Baarslag, Catholijn M. Jonker, and Takayuki Ito. ANAC 2017: Repeated multilateral negotiation league. In Advances in Automated Negotiations, pages 101-115, Singapore, 2021. Springer Singapore.

See Also

Paper: https://doi.org/10.1007/978-981-16-0471-3_7

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/rubick.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
class Rubick(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's Rubick agent.

    **ANAC 2017 Individual Utility Category Finalist**.

    Rubick Agent by Okan Tunali is a complex time-based conceder enriched
    with frequency-based opponent modeling. It maintains the highest utility
    ever received as a lower bound and uses randomized Boulware-style
    concession with increasing variance over time.

    **Offering Strategy:**
    Generates bids above a target utility using opponent model insights:

    - Searches for bids that maximize intersection with opponent's
      most frequently offered values (frequency-based search)
    - If no suitable bid found via opponent model, falls back to
      nearest bid to target utility
    - Near deadline (t > 0.995), offers from a cached list of
      previously accepted bids

    Target utility follows randomized Boulware with power parameter
    randomly selected based on max received utility.

    **Acceptance Strategy:**
    Time-based with randomness to prevent exploitation:

    $$target = 1 - t^{power} \cdot |\mathcal{N}(0, 1/3)|$$

    where power is randomly 2, 3, or 10 based on opponent behavior.
    The target is bounded by the maximum received utility.
    Accepts if opponent offer exceeds target or time > 0.999.

    **Opponent Modeling:**
    Employs frequency-based opponent modeling:

    - Tracks value frequencies for each issue per opponent
    - Extracts "bags" of preferred values (above median frequency)
    - Scores bids by counting intersections with opponent preferences
    - Maintains separate models for multilateral scenarios

    Also keeps a sorted list of bids that were accepted by opponents
    in previous negotiations for use near the deadline.

    References:
        .. [Aydogan2021] Reyhan Aydogan, Katsuhide Fujita, Tim Baarslag,
           Catholijn M. Jonker, and Takayuki Ito. ANAC 2017: Repeated
           multilateral negotiation league. In Advances in Automated
           Negotiations, pages 101-115, Singapore, 2021. Springer Singapore.

    See Also:
        Paper: https://doi.org/10.1007/978-981-16-0471-3_7

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLRubick

AhBuNeAgent

negmas_negolog.AhBuNeAgent

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's AhBuNeAgent.

ANAC 2020 Winner (Individual Utility category).

AhBuNeAgent (developed by Ahmet Burak Yildirim) uses similarity maps and linear ordering to estimate preferences and make strategic decisions about preference elicitation vs. utility maximization.

Offering Strategy: - Uses similarity maps to find bids compatible with estimated preferences - Time-based concession with utility lower bound that decreases over time - Early phase (t < 0.015): explores bids to gather preference information - Takes estimated opponent preferences into account when selecting offers - Near deadline: considers opponent's elicited bids as candidates

Acceptance Strategy: - Accepts if bid has high similarity (>= 0.9) to best known outcomes - Uses opponent model to validate bids as "compromised" (acceptable to opponent) - Near deadline: relaxes acceptance threshold by max compromise amount

Opponent Modeling: Similarity Map approach: - Tracks opponent's bidding history to build linear ordering - Estimates issue importance from bid content analysis - Identifies "forbidden" (worst) and "available" (best) values - Determines if bids are "compromised" (likely acceptable to opponent)

References

.. [Yildirim2023] Yildirim, A.B., Sunman, N., Aydogan, R. (2023). AhBuNe Agent: Winner of the Eleventh International Automated Negotiating Agent Competition (ANAC 2020). In: Recent Advances in Agent-Based Negotiation. Studies in Computational Intelligence, vol 1092. Springer, Singapore.

See Also

Paper: https://doi.org/10.1007/978-981-99-0561-4_6

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/ahbune.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
class AhBuNeAgent(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's AhBuNeAgent.

    **ANAC 2020 Winner** (Individual Utility category).

    AhBuNeAgent (developed by Ahmet Burak Yildirim) uses similarity maps
    and linear ordering to estimate preferences and make strategic decisions
    about preference elicitation vs. utility maximization.

    **Offering Strategy:**
        - Uses similarity maps to find bids compatible with estimated preferences
        - Time-based concession with utility lower bound that decreases over time
        - Early phase (t < 0.015): explores bids to gather preference information
        - Takes estimated opponent preferences into account when selecting offers
        - Near deadline: considers opponent's elicited bids as candidates

    **Acceptance Strategy:**
        - Accepts if bid has high similarity (>= 0.9) to best known outcomes
        - Uses opponent model to validate bids as "compromised" (acceptable
          to opponent)
        - Near deadline: relaxes acceptance threshold by max compromise amount

    **Opponent Modeling:**
        Similarity Map approach:
        - Tracks opponent's bidding history to build linear ordering
        - Estimates issue importance from bid content analysis
        - Identifies "forbidden" (worst) and "available" (best) values
        - Determines if bids are "compromised" (likely acceptable to opponent)

    References:
        .. [Yildirim2023] Yildirim, A.B., Sunman, N., Aydogan, R. (2023).
           AhBuNe Agent: Winner of the Eleventh International Automated
           Negotiating Agent Competition (ANAC 2020). In: Recent Advances
           in Agent-Based Negotiation. Studies in Computational Intelligence,
           vol 1092. Springer, Singapore.

    See Also:
        Paper: https://doi.org/10.1007/978-981-99-0561-4_6

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLAhBuNeAgent

ParsAgent

negmas_negolog.ParsAgent

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's ParsAgent.

ANAC 2015 Individual Utility Category Finalist.

ParsAgent by Zahra Khosravimehr from Amirkabir University of Technology uses a hybrid bidding strategy combining time-dependent, random, and frequency-based approaches to propose high-utility offers close to opponent preferences, increasing the likelihood of early agreement.

Offering Strategy: Employs a multi-step bid generation process:

  1. First checks if there's a mutually beneficial bid from the intersection of both opponents' preferences (in multilateral).
  2. If not found, constructs a bid using:
  3. Mutual issue values (agreed by both opponents based on frequency)
  4. Own best values for non-mutual issues
  5. Falls back to modifying the best bid on the worst-weighted issue

Target utility follows Boulware-style concession:

\[target(t) = 1 - t^{1/e}\]

where e = 0.15 (or 0.2 with discount factor). Minimum threshold is 0.7.

Acceptance Strategy: Simple time-dependent acceptance: accepts if opponent's offer utility exceeds the target utility at current time. The target decreases from 1.0 towards 0.7 following the Boulware curve.

Opponent Modeling: Frequency-based modeling for each opponent:

  • Tracks repeated values for each issue across opponent bids
  • Identifies mutual preferences between opponents (values both opponents frequently request)
  • Maintains sorted list of opponent bids by utility
  • Searches for Nash-like outcomes using common preferences
References

.. [Khosravimehr2017] Khosravimehr, Z., Nassiri-Mofakham, F. (2017). Pars Agent: Hybrid Time-Dependent, Random and Frequency-Based Bidding and Acceptance Strategies in Multilateral Negotiations. In: Fujita, K., et al. Modern Approaches to Agent-based Complex Automated Negotiation. Studies in Computational Intelligence, vol 674. Springer, Cham.

See Also

Paper: https://doi.org/10.1007/978-3-319-51563-2_12

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/pars.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
class ParsAgent(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's ParsAgent.

    **ANAC 2015 Individual Utility Category Finalist**.

    ParsAgent by Zahra Khosravimehr from Amirkabir University of Technology
    uses a hybrid bidding strategy combining time-dependent, random, and
    frequency-based approaches to propose high-utility offers close to
    opponent preferences, increasing the likelihood of early agreement.

    **Offering Strategy:**
    Employs a multi-step bid generation process:

    1. First checks if there's a mutually beneficial bid from the
       intersection of both opponents' preferences (in multilateral).
    2. If not found, constructs a bid using:
       - Mutual issue values (agreed by both opponents based on frequency)
       - Own best values for non-mutual issues
    3. Falls back to modifying the best bid on the worst-weighted issue

    Target utility follows Boulware-style concession:

    $$target(t) = 1 - t^{1/e}$$

    where e = 0.15 (or 0.2 with discount factor). Minimum threshold is 0.7.

    **Acceptance Strategy:**
    Simple time-dependent acceptance: accepts if opponent's offer
    utility exceeds the target utility at current time. The target
    decreases from 1.0 towards 0.7 following the Boulware curve.

    **Opponent Modeling:**
    Frequency-based modeling for each opponent:

    - Tracks repeated values for each issue across opponent bids
    - Identifies mutual preferences between opponents (values both
      opponents frequently request)
    - Maintains sorted list of opponent bids by utility
    - Searches for Nash-like outcomes using common preferences

    References:
        .. [Khosravimehr2017] Khosravimehr, Z., Nassiri-Mofakham, F. (2017).
           Pars Agent: Hybrid Time-Dependent, Random and Frequency-Based
           Bidding and Acceptance Strategies in Multilateral Negotiations.
           In: Fujita, K., et al. Modern Approaches to Agent-based Complex
           Automated Negotiation. Studies in Computational Intelligence,
           vol 674. Springer, Cham.

    See Also:
        Paper: https://doi.org/10.1007/978-3-319-51563-2_12

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLParsAgent

ParsCatAgent

negmas_negolog.ParsCatAgent

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's ParsCatAgent.

ANAC 2016 Individual Utility Category Runner-up.

ParsCatAgent is developed by Amirkabir University of Technology and uses a time-dependent bidding strategy with a complex piecewise acceptance function. The agent maintains a history of opponent bids and uses time-based thresholds that vary across different negotiation phases.

Offering Strategy: The agent generates random bids within a narrow utility window around a time-varying threshold. The threshold decreases over time but with different rates across negotiation phases:

- t < 0.5: threshold = 1.0 - t/4 (slow concession)
- 0.5 <= t < 0.8: threshold = 0.9 - t/5
- 0.8 <= t < 0.9: threshold = 0.7 + t/5 (strategic increase)
- 0.9 <= t < 0.95: threshold = 0.8 + t/5
- t >= 0.95: threshold = 1.0 - t/4 - 0.01

The search window around the threshold is typically +/- 0.01 to 0.02.
If the best opponent bid has higher utility than the generated bid
(in bilateral negotiations), it returns the opponent's best bid.

Acceptance Strategy: Uses a complex piecewise function based on negotiation time with 10 distinct phases, creating an oscillating acceptance threshold:

- Starts high (1.0), drops to ~0.9 by t=0.25
- Oscillates between 0.7-1.0 through mid-game
- Ends around 0.5-0.7 in the final phase

This non-monotonic pattern makes the agent's behavior harder to
predict and exploit.

Opponent Modeling: Maintains a history of opponent bids with utilities and timestamps. Uses the best bid from opponent history as a fallback offer when the generated bid has lower utility.

References

.. [Aydogan2021] Reyhan Aydogan, Katsuhide Fujita, Tim Baarslag, Catholijn M. Jonker, and Takayuki Ito. ANAC 2017: Repeated multilateral negotiation league. In Advances in Automated Negotiations, pages 101-115, Singapore, 2021. Springer Singapore.

See Also

Paper: https://doi.org/10.1007/978-981-16-0471-3_7

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/parscat.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
class ParsCatAgent(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's ParsCatAgent.

    **ANAC 2016 Individual Utility Category Runner-up**.

    ParsCatAgent is developed by Amirkabir University of Technology and uses
    a time-dependent bidding strategy with a complex piecewise acceptance
    function. The agent maintains a history of opponent bids and uses
    time-based thresholds that vary across different negotiation phases.

    **Offering Strategy:**
        The agent generates random bids within a narrow utility window around
        a time-varying threshold. The threshold decreases over time but with
        different rates across negotiation phases:

        - t < 0.5: threshold = 1.0 - t/4 (slow concession)
        - 0.5 <= t < 0.8: threshold = 0.9 - t/5
        - 0.8 <= t < 0.9: threshold = 0.7 + t/5 (strategic increase)
        - 0.9 <= t < 0.95: threshold = 0.8 + t/5
        - t >= 0.95: threshold = 1.0 - t/4 - 0.01

        The search window around the threshold is typically +/- 0.01 to 0.02.
        If the best opponent bid has higher utility than the generated bid
        (in bilateral negotiations), it returns the opponent's best bid.

    **Acceptance Strategy:**
        Uses a complex piecewise function based on negotiation time with 10
        distinct phases, creating an oscillating acceptance threshold:

        - Starts high (1.0), drops to ~0.9 by t=0.25
        - Oscillates between 0.7-1.0 through mid-game
        - Ends around 0.5-0.7 in the final phase

        This non-monotonic pattern makes the agent's behavior harder to
        predict and exploit.

    **Opponent Modeling:**
        Maintains a history of opponent bids with utilities and timestamps.
        Uses the best bid from opponent history as a fallback offer when
        the generated bid has lower utility.

    References:
        .. [Aydogan2021] Reyhan Aydogan, Katsuhide Fujita, Tim Baarslag,
           Catholijn M. Jonker, and Takayuki Ito. ANAC 2017: Repeated
           multilateral negotiation league. In Advances in Automated
           Negotiations, pages 101-115, Singapore, 2021. Springer Singapore.

    See Also:
        Paper: https://doi.org/10.1007/978-981-16-0471-3_7

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLParsCatAgent

PonPokoAgent

negmas_negolog.PonPokoAgent

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's PonPokoAgent.

ANAC 2017 Individual Utility Category Winner.

PonPokoAgent by Takaki Matsune employs a randomized multi-strategy approach that makes it difficult for opponents to predict its behavior. At the start of each negotiation session, it randomly selects one of 5 different bidding patterns, each with distinct concession characteristics.

Offering Strategy: The agent randomly selects one of 5 bidding patterns at initialization:

- **Pattern 0**: Sinusoidal oscillation with slow linear decline.
  High/Low thresholds follow sin(40t) pattern.
- **Pattern 1**: Linear concession from 1.0, slow decline to 0.78.
- **Pattern 2**: Sinusoidal with larger amplitude (sin(20t)).
- **Pattern 3**: Very conservative, minimal concession (0.95-1.0)
  until deadline when it drops to 0.7.
- **Pattern 4**: Sinusoidal pattern tied to time (sin(20t) * t).

Bids are selected from the pre-sorted bid space within the
[threshold_low, threshold_high] utility range.

Acceptance Strategy: Accepts if the opponent's offer has utility greater than the current threshold_low value. This creates a simple but effective acceptance criterion that varies with the selected bidding pattern.

Opponent Modeling: PonPokoAgent does not employ explicit opponent modeling. Its strength lies in the unpredictability of its randomly selected strategy, making it resistant to exploitation by adaptive opponents.

References

.. [Aydogan2021] Reyhan Aydogan, Katsuhide Fujita, Tim Baarslag, Catholijn M. Jonker, and Takayuki Ito. ANAC 2017: Repeated multilateral negotiation league. In Advances in Automated Negotiations, pages 101-115, Singapore, 2021. Springer Singapore.

See Also

Paper: https://doi.org/10.1007/978-981-16-0471-3_7

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/ponpoko.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
class PonPokoAgent(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's PonPokoAgent.

    **ANAC 2017 Individual Utility Category Winner**.

    PonPokoAgent by Takaki Matsune employs a randomized multi-strategy approach
    that makes it difficult for opponents to predict its behavior. At the start
    of each negotiation session, it randomly selects one of 5 different bidding
    patterns, each with distinct concession characteristics.

    **Offering Strategy:**
        The agent randomly selects one of 5 bidding patterns at initialization:

        - **Pattern 0**: Sinusoidal oscillation with slow linear decline.
          High/Low thresholds follow sin(40t) pattern.
        - **Pattern 1**: Linear concession from 1.0, slow decline to 0.78.
        - **Pattern 2**: Sinusoidal with larger amplitude (sin(20t)).
        - **Pattern 3**: Very conservative, minimal concession (0.95-1.0)
          until deadline when it drops to 0.7.
        - **Pattern 4**: Sinusoidal pattern tied to time (sin(20t) * t).

        Bids are selected from the pre-sorted bid space within the
        [threshold_low, threshold_high] utility range.

    **Acceptance Strategy:**
        Accepts if the opponent's offer has utility greater than the current
        threshold_low value. This creates a simple but effective acceptance
        criterion that varies with the selected bidding pattern.

    **Opponent Modeling:**
        PonPokoAgent does not employ explicit opponent modeling. Its strength
        lies in the unpredictability of its randomly selected strategy, making
        it resistant to exploitation by adaptive opponents.

    References:
        .. [Aydogan2021] Reyhan Aydogan, Katsuhide Fujita, Tim Baarslag,
           Catholijn M. Jonker, and Takayuki Ito. ANAC 2017: Repeated
           multilateral negotiation league. In Advances in Automated
           Negotiations, pages 101-115, Singapore, 2021. Springer Singapore.

    See Also:
        Paper: https://doi.org/10.1007/978-981-16-0471-3_7

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLPonPokoAgent

RandomDance

negmas_negolog.RandomDance

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's RandomDance agent.

ANAC 2015 Individual Utility Category Finalist.

RandomDance Agent by Shinji Kakimoto proposes an opponent modeling approach using multiple weighted utility estimation functions. The agent randomly selects among different weighting schemes, making it unpredictable while still being responsive to opponent behavior.

Offering Strategy: Searches for bids that balance self-utility with estimated opponent utility using weighted combination:

1. For each issue, selects values that maximize weighted sum of
   estimated utilities across all parties
2. Adjusts own weight iteratively (0 to 10) until finding a bid
   above the target utility
3. Target utility is adaptive: starts at estimated Nash point and
   decreases following t^discount curve

Falls back to best bid if no suitable bid found.

Acceptance Strategy: Accepts based on target utility comparison with safety margin:

- Tracks time per round to estimate remaining rounds
- If remaining rounds <= 5, accepts to avoid negotiation failure
- Otherwise accepts if opponent's offer exceeds target utility

Opponent Modeling: Uses a library of multiple PlayerData models with different learning rates (delta = 1.0, 1.05, 0.55):

- Each model tracks value frequencies with exponential weighting
- Issue weights derived from maximum value frequencies
- Randomly selects which model to use for each decision
- Tracks Nash-optimal opponent (whose bids maximize product of
  estimated utilities) for weighting decisions

Three weighting strategies randomly selected:
1. Nash-based: weight by Nash optimality history
2. Equal: all opponents weighted equally
3. Alternating: alternate between opponents
References

.. [Kakimoto2017] Kakimoto, S., Fujita, K. (2017). RandomDance: Compromising Strategy Considering Interdependencies of Issues with Randomness. In: Fujita, K., et al. Modern Approaches to Agent-based Complex Automated Negotiation. Studies in Computational Intelligence, vol 674. Springer, Cham.

See Also

Paper: https://doi.org/10.1007/978-3-319-51563-2_13

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/random_dance.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
class RandomDance(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's RandomDance agent.

    **ANAC 2015 Individual Utility Category Finalist**.

    RandomDance Agent by Shinji Kakimoto proposes an opponent modeling
    approach using multiple weighted utility estimation functions. The
    agent randomly selects among different weighting schemes, making it
    unpredictable while still being responsive to opponent behavior.

    **Offering Strategy:**
        Searches for bids that balance self-utility with estimated opponent
        utility using weighted combination:

        1. For each issue, selects values that maximize weighted sum of
           estimated utilities across all parties
        2. Adjusts own weight iteratively (0 to 10) until finding a bid
           above the target utility
        3. Target utility is adaptive: starts at estimated Nash point and
           decreases following t^discount curve

        Falls back to best bid if no suitable bid found.

    **Acceptance Strategy:**
        Accepts based on target utility comparison with safety margin:

        - Tracks time per round to estimate remaining rounds
        - If remaining rounds <= 5, accepts to avoid negotiation failure
        - Otherwise accepts if opponent's offer exceeds target utility

    **Opponent Modeling:**
        Uses a library of multiple PlayerData models with different
        learning rates (delta = 1.0, 1.05, 0.55):

        - Each model tracks value frequencies with exponential weighting
        - Issue weights derived from maximum value frequencies
        - Randomly selects which model to use for each decision
        - Tracks Nash-optimal opponent (whose bids maximize product of
          estimated utilities) for weighting decisions

        Three weighting strategies randomly selected:
        1. Nash-based: weight by Nash optimality history
        2. Equal: all opponents weighted equally
        3. Alternating: alternate between opponents

    References:
        .. [Kakimoto2017] Kakimoto, S., Fujita, K. (2017). RandomDance:
           Compromising Strategy Considering Interdependencies of Issues
           with Randomness. In: Fujita, K., et al. Modern Approaches to
           Agent-based Complex Automated Negotiation. Studies in
           Computational Intelligence, vol 674. Springer, Cham.

    See Also:
        Paper: https://doi.org/10.1007/978-3-319-51563-2_13

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLRandomDance

AgentBuyog

negmas_negolog.AgentBuyog

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's AgentBuyog.

ANAC 2015 Individual Utility Category Runner-up.

AgentBuyog estimates the opponent's concession function using regression analysis and uses this to determine optimal acceptance thresholds. It also estimates opponent preferences to find bids near the Kalai point (social welfare maximum).

Offering Strategy: Selects bids based on domain competitiveness and opponent difficulty:

  1. Calculates acceptance threshold based on estimated opponent difficulty and time-based concession:
\[threshold = minPoint + (1 - minPoint) \cdot (1 - t^{1.8})\]
  1. Searches for bids at or above threshold that are closest to the estimated Kalai point (maximizing social welfare)
  2. If common bids exist (offered by multiple opponents), prefers those with highest utility

Near deadline (remaining rounds <= 3), threshold is halved.

Acceptance Strategy: Multi-criteria acceptance based on:

  • Most recent offer utility vs. threshold
  • Best agreeable bid utility (common to both opponents)
  • Generated bid utility

Accepts if opponent's offer exceeds all other options and the acceptance threshold, especially when near deadline.

Opponent Modeling: Sophisticated multi-component model:

  • Concession estimation: Uses weighted regression to fit exponential concession function exp(alpha) * t^beta to opponent bid utilities over time
  • Leniency calculation: Derived from slope of estimated concession curve, adjusted by a leniency factor
  • Preference estimation: Frequency-based issue weight and value estimation, normalized after each update
  • Kalai point estimation: Finds social welfare maximum using estimated opponent preferences
  • Agent difficulty: Combined metric of leniency and domain competitiveness to assess how hard to negotiate with
References

.. [Fujita2017] Fujita, K., Aydogan, R., Baarslag, T., Hindriks, K., Ito, T., Jonker, C. (2017). The Sixth Automated Negotiating Agents Competition (ANAC 2015). In: Fujita, K., et al. Modern Approaches to Agent-based Complex Automated Negotiation. Studies in Computational Intelligence, vol 674. Springer, Cham.

See Also

Paper: https://doi.org/10.1007/978-3-319-51563-2_9

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/agent_buyog.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
class AgentBuyog(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's AgentBuyog.

    **ANAC 2015 Individual Utility Category Runner-up**.

    AgentBuyog estimates the opponent's concession function using regression
    analysis and uses this to determine optimal acceptance thresholds. It
    also estimates opponent preferences to find bids near the Kalai point
    (social welfare maximum).

    **Offering Strategy:**
    Selects bids based on domain competitiveness and opponent difficulty:

    1. Calculates acceptance threshold based on estimated opponent
       difficulty and time-based concession:

    $$threshold = minPoint + (1 - minPoint) \cdot (1 - t^{1.8})$$

    2. Searches for bids at or above threshold that are closest to
       the estimated Kalai point (maximizing social welfare)
    3. If common bids exist (offered by multiple opponents), prefers
       those with highest utility

    Near deadline (remaining rounds <= 3), threshold is halved.

    **Acceptance Strategy:**
    Multi-criteria acceptance based on:

    - Most recent offer utility vs. threshold
    - Best agreeable bid utility (common to both opponents)
    - Generated bid utility

    Accepts if opponent's offer exceeds all other options and the
    acceptance threshold, especially when near deadline.

    **Opponent Modeling:**
    Sophisticated multi-component model:

    - **Concession estimation**: Uses weighted regression to fit
      exponential concession function exp(alpha) * t^beta to opponent
      bid utilities over time
    - **Leniency calculation**: Derived from slope of estimated
      concession curve, adjusted by a leniency factor
    - **Preference estimation**: Frequency-based issue weight and
      value estimation, normalized after each update
    - **Kalai point estimation**: Finds social welfare maximum
      using estimated opponent preferences
    - **Agent difficulty**: Combined metric of leniency and domain
      competitiveness to assess how hard to negotiate with

    References:
        .. [Fujita2017] Fujita, K., Aydogan, R., Baarslag, T., Hindriks, K.,
           Ito, T., Jonker, C. (2017). The Sixth Automated Negotiating
           Agents Competition (ANAC 2015). In: Fujita, K., et al. Modern
           Approaches to Agent-based Complex Automated Negotiation. Studies
           in Computational Intelligence, vol 674. Springer, Cham.

    See Also:
        Paper: https://doi.org/10.1007/978-3-319-51563-2_9

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLAgentBuyog

Kawaii

negmas_negolog.Kawaii

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's Kawaii agent.

ANAC 2015 Individual Utility Category Runner-up.

Kawaii is a negotiation agent that uses Simulated Annealing for bid search and a time-dependent conceding strategy. It adapts its acceptance threshold based on the number of accepting opponents in multilateral negotiations.

Offering Strategy: Uses Simulated Annealing to search for bids near the target utility:

  1. First attempts relative utility search (for linear utility spaces) by selecting values that sum to the target concession amount
  2. Falls back to Simulated Annealing with parameters:
  3. Start temperature: 1.0
  4. End temperature: 0.0001
  5. Cooling rate: 0.999

The search minimizes the distance to target utility while staying above it. Returns the maximum utility bid if no suitable bid found.

Acceptance Strategy: Time-dependent threshold with conceder behavior (exponent = 2):

\[threshold(t) = 1 - (1 - a) \cdot t^2\]

where a = 0.8 is the minimum threshold.

In multilateral scenarios, the threshold is reduced based on how many opponents have already accepted:

\[threshold -= (threshold - minThreshold) \cdot rac{acceptCount}{numOpponents}\]

This encourages acceptance when close to agreement.

Opponent Modeling: Tracks which opponents have made accepting moves (offered bids close to previous offers). This information adjusts the acceptance threshold to facilitate agreement when multiple parties are close to consensus.

References

.. [Baarslag2015] Baarslag, T., Aydogan, R., Hindriks, K. V., Fujita, K., Ito, T., & Jonker, C. M. (2015). The Automated Negotiating Agents Competition, 2010-2015. AI Magazine, 36(4), 115-118.

See Also

Paper: https://doi.org/10.1609/aimag.v36i4.2609

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/kawaii.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
class Kawaii(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's Kawaii agent.

    **ANAC 2015 Individual Utility Category Runner-up**.

    Kawaii is a negotiation agent that uses Simulated Annealing for bid
    search and a time-dependent conceding strategy. It adapts its
    acceptance threshold based on the number of accepting opponents in
    multilateral negotiations.

    **Offering Strategy:**
    Uses Simulated Annealing to search for bids near the target utility:

    1. First attempts relative utility search (for linear utility spaces)
       by selecting values that sum to the target concession amount
    2. Falls back to Simulated Annealing with parameters:
       - Start temperature: 1.0
       - End temperature: 0.0001
       - Cooling rate: 0.999

    The search minimizes the distance to target utility while staying
    above it. Returns the maximum utility bid if no suitable bid found.

    **Acceptance Strategy:**
    Time-dependent threshold with conceder behavior (exponent = 2):

    $$threshold(t) = 1 - (1 - a) \cdot t^2$$

    where a = 0.8 is the minimum threshold.

    In multilateral scenarios, the threshold is reduced based on how
    many opponents have already accepted:

    $$threshold -= (threshold - minThreshold) \cdot \frac{acceptCount}{numOpponents}$$

    This encourages acceptance when close to agreement.

    **Opponent Modeling:**
    Tracks which opponents have made accepting moves (offered bids
    close to previous offers). This information adjusts the acceptance
    threshold to facilitate agreement when multiple parties are close
    to consensus.

    References:
        .. [Baarslag2015] Baarslag, T., Aydogan, R., Hindriks, K. V.,
           Fujita, K., Ito, T., & Jonker, C. M. (2015). The Automated
           Negotiating Agents Competition, 2010-2015. AI Magazine,
           36(4), 115-118.

    See Also:
        Paper: https://doi.org/10.1609/aimag.v36i4.2609

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLKawaii

Caduceus

negmas_negolog.Caduceus

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's Caduceus agent.

ANAC 2016 Winner (Individual Utility category).

Caduceus (developed by Taha Gunes) combines multiple negotiation experts using ideas from algorithm portfolios, mixture of experts, and genetic algorithms to make collective decisions.

Offering Strategy: - Portfolio of 5 expert agents: ParsAgent, RandomDance, Kawaii, Atlas3, and Caduceus2015 - Early phase (t < 0.83): offers the best possible bid - Crossover strategy: each expert suggests a bid, then majority voting on each issue value determines final bid content - Experts are weighted by expertise scores (100, 10, 5, 3, 1) - Stochastic selection based on expertise levels

Acceptance Strategy: - Weighted voting among expert agents - Accepts if weighted score of "accept" votes exceeds "bid" votes - Each expert's vote weighted by its expertise score

Opponent Modeling: Delegated to individual expert agents in the portfolio: - ParsAgent, Atlas3, Kawaii each have their own opponent models - Collective decision benefits from diverse modeling approaches

References

.. [Gunes2017] Gunes, T.D., Arditi, E., Aydogan, R. (2017). Collective Voice of Experts in Multilateral Negotiation. In: PRIMA 2017: Principles and Practice of Multi-Agent Systems. Lecture Notes in Computer Science, vol 10621. Springer, Cham.

See Also

Paper: https://doi.org/10.1007/978-3-319-69131-2_27

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/caduceus.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
class Caduceus(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's Caduceus agent.

    **ANAC 2016 Winner** (Individual Utility category).

    Caduceus (developed by Taha Gunes) combines multiple negotiation experts
    using ideas from algorithm portfolios, mixture of experts, and genetic
    algorithms to make collective decisions.

    **Offering Strategy:**
        - Portfolio of 5 expert agents: ParsAgent, RandomDance, Kawaii,
          Atlas3, and Caduceus2015
        - Early phase (t < 0.83): offers the best possible bid
        - Crossover strategy: each expert suggests a bid, then majority
          voting on each issue value determines final bid content
        - Experts are weighted by expertise scores (100, 10, 5, 3, 1)
        - Stochastic selection based on expertise levels

    **Acceptance Strategy:**
        - Weighted voting among expert agents
        - Accepts if weighted score of "accept" votes exceeds "bid" votes
        - Each expert's vote weighted by its expertise score

    **Opponent Modeling:**
        Delegated to individual expert agents in the portfolio:
        - ParsAgent, Atlas3, Kawaii each have their own opponent models
        - Collective decision benefits from diverse modeling approaches

    References:
        .. [Gunes2017] Gunes, T.D., Arditi, E., Aydogan, R. (2017). Collective
           Voice of Experts in Multilateral Negotiation. In: PRIMA 2017:
           Principles and Practice of Multi-Agent Systems. Lecture Notes in
           Computer Science, vol 10621. Springer, Cham.

    See Also:
        Paper: https://doi.org/10.1007/978-3-319-69131-2_27

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLCaduceus

Caduceus2015

negmas_negolog.Caduceus2015

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's Caduceus2015 agent.

ANAC 2015 Competition Agent.

Caduceus2015 by Taha Gunes is a sub-agent developed for the Caduceus multilateral negotiation system. It uses Nash product optimization to find mutually beneficial outcomes and employs frequency-based opponent modeling to estimate opponent preferences.

Offering Strategy: Two-phase bidding approach based on time:

  1. Early phase (t < 0.83): Offers the best bid (maximum utility) to establish a strong opening position.

  2. Later phase (t >= 0.83): Calculates Nash product across all parties using estimated opponent utility spaces:

  3. Computes Nash bid that maximizes product of utilities
  4. Uses CounterOfferGenerator to generate bids around Nash point
  5. Ensures bid utility stays above reservation value (min 0.75)

If generated bid has lower utility than opponent's last offer (by margin > 0.2), accepts instead.

Acceptance Strategy: Implicit acceptance based on bid comparison: if the opponent's previous bid has utility exceeding the generated counter-offer by more than 0.2, the agent accepts. This creates a dynamic acceptance threshold based on what the agent can offer.

Opponent Modeling: Frequency-based preference estimation with time-weighted updates:

  • Tracks issue-value frequencies using a "round value" weight:
\[roundValue = 2t^2 - 101t + 100\]

This gives high weight to early observations that decreases over time.

  • Extra weight given to values that remain unchanged between consecutive opponent bids (stability bonus)
  • Constructs SaneUtilitySpace for each opponent to estimate their preferences
References

.. [Gunes2017] Gunes, T.D., Arditi, E., Aydogan, R. (2017). Collective Voice of Experts in Multilateral Negotiation. In: An, B., Bazzan, A., Leite, J., Villata, S., van der Torre, L. (eds) PRIMA 2017: Principles and Practice of Multi-Agent Systems. Lecture Notes in Computer Science, vol 10621. Springer, Cham.

See Also

Paper: https://doi.org/10.1007/978-3-319-69131-2_27

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/caduceus2015.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
class Caduceus2015(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's Caduceus2015 agent.

    **ANAC 2015 Competition Agent**.

    Caduceus2015 by Taha Gunes is a sub-agent developed for the Caduceus
    multilateral negotiation system. It uses Nash product optimization
    to find mutually beneficial outcomes and employs frequency-based
    opponent modeling to estimate opponent preferences.

    **Offering Strategy:**
    Two-phase bidding approach based on time:

    1. **Early phase (t < 0.83)**: Offers the best bid (maximum utility)
       to establish a strong opening position.

    2. **Later phase (t >= 0.83)**: Calculates Nash product across all
       parties using estimated opponent utility spaces:
       - Computes Nash bid that maximizes product of utilities
       - Uses CounterOfferGenerator to generate bids around Nash point
       - Ensures bid utility stays above reservation value (min 0.75)

    If generated bid has lower utility than opponent's last offer
    (by margin > 0.2), accepts instead.

    **Acceptance Strategy:**
    Implicit acceptance based on bid comparison: if the opponent's
    previous bid has utility exceeding the generated counter-offer
    by more than 0.2, the agent accepts. This creates a dynamic
    acceptance threshold based on what the agent can offer.

    **Opponent Modeling:**
    Frequency-based preference estimation with time-weighted updates:

    - Tracks issue-value frequencies using a "round value" weight:

    $$roundValue = 2t^2 - 101t + 100$$

    This gives high weight to early observations that decreases
    over time.

    - Extra weight given to values that remain unchanged between
      consecutive opponent bids (stability bonus)
    - Constructs SaneUtilitySpace for each opponent to estimate
      their preferences

    References:
        .. [Gunes2017] Gunes, T.D., Arditi, E., Aydogan, R. (2017).
           Collective Voice of Experts in Multilateral Negotiation.
           In: An, B., Bazzan, A., Leite, J., Villata, S., van der Torre, L.
           (eds) PRIMA 2017: Principles and Practice of Multi-Agent Systems.
           Lecture Notes in Computer Science, vol 10621. Springer, Cham.

    See Also:
        Paper: https://doi.org/10.1007/978-3-319-69131-2_27

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLCaduceus2015

IAMhaggler

negmas_negolog.IAMhaggler

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's IAMhaggler agent.

ANAC 2012 Winner (Nash Product category).

IAMhaggler (developed by Colin R. Williams at University of Southampton) uses Gaussian Process regression to predict opponent behavior and optimize concession timing.

Offering Strategy: - Uses Gaussian Process to predict when opponent will make maximum concession - Calculates expected utility surface over time and utility dimensions - Target utility based on interpolation toward predicted best agreement - Limits concession based on observed opponent bidding range - Risk-aware utility function with configurable risk parameter

Acceptance Strategy: - Accepts if opponent's offer * multiplier >= target utility - Accepts if opponent's offer * multiplier >= maximum aspiration (0.9) - Accepts if opponent's offer >= planned bid utility - Multiple acceptance thresholds for robustness

Opponent Modeling: Gaussian Process regression approach: - Tracks opponent utilities over time slots - Fits GP model to predict future opponent concessions - Calculates probability distribution of opponent's future offers - Uses predictions to optimize concession timing - Incorporates discounting factor for time-sensitive domains

References

.. [Williams2012] Williams, C.R., Robu, V., Gerding, E.H., Jennings, N.R. (2012). IAMhaggler: A Negotiation Agent for Complex Environments. In: New Trends in Agent-Based Complex Automated Negotiations. Studies in Computational Intelligence, vol 383. Springer.

See Also

Paper: https://doi.org/10.1007/978-3-642-24696-8_10

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/iamhaggler.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
class IAMhaggler(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's IAMhaggler agent.

    **ANAC 2012 Winner** (Nash Product category).

    IAMhaggler (developed by Colin R. Williams at University of Southampton)
    uses Gaussian Process regression to predict opponent behavior and
    optimize concession timing.

    **Offering Strategy:**
        - Uses Gaussian Process to predict when opponent will make maximum
          concession
        - Calculates expected utility surface over time and utility dimensions
        - Target utility based on interpolation toward predicted best agreement
        - Limits concession based on observed opponent bidding range
        - Risk-aware utility function with configurable risk parameter

    **Acceptance Strategy:**
        - Accepts if opponent's offer * multiplier >= target utility
        - Accepts if opponent's offer * multiplier >= maximum aspiration (0.9)
        - Accepts if opponent's offer >= planned bid utility
        - Multiple acceptance thresholds for robustness

    **Opponent Modeling:**
        Gaussian Process regression approach:
        - Tracks opponent utilities over time slots
        - Fits GP model to predict future opponent concessions
        - Calculates probability distribution of opponent's future offers
        - Uses predictions to optimize concession timing
        - Incorporates discounting factor for time-sensitive domains

    References:
        .. [Williams2012] Williams, C.R., Robu, V., Gerding, E.H., Jennings, N.R.
           (2012). IAMhaggler: A Negotiation Agent for Complex Environments.
           In: New Trends in Agent-Based Complex Automated Negotiations.
           Studies in Computational Intelligence, vol 383. Springer.

    See Also:
        Paper: https://doi.org/10.1007/978-3-642-24696-8_10

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLIAMhaggler

LuckyAgent2022

negmas_negolog.LuckyAgent2022

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's LuckyAgent2022.

ANAC 2022 Runner-up (Individual Utility category).

LuckyAgent2022 (developed by Arash Ebrahimnezhad) uses BOA (Bidding, Opponent modeling, Acceptance) components with a novel Stop-Learning Mechanism (SLM) adapted from multi-armed bandit theory to prevent overfitting.

Offering Strategy: - Time-dependent bidding with adaptive thresholds - Divides target utility range into multiple goals (NUMBER_OF_GOALS=5) - Randomly selects from bids matching utility goals - Weights bid selection by estimated opponent utility - Uses sinusoidal variation in lower threshold for exploration

Acceptance Strategy: - Condition 1: Offer exceeds acceptance threshold and reservation - Condition 2: Near deadline (t > 0.97) with offer above minimum - Condition 3: Weighted offer utility exceeds next planned bid utility - Multiple acceptance conditions increase agreement likelihood

Opponent Modeling: Frequency-based model with Stop-Learning Mechanism: - Tracks opponent bids to estimate preferences - Uses multi-armed bandit approach to balance exploration/exploitation - SLM prevents overfitting by stopping learning at optimal point - Model used to weight bid selection toward opponent preferences

References

.. [Ebrahimnezhad2022] A. Ebrahimnezhad and F. Nassiri-Mofakham, LuckyAgent2022: A Stop-Learning Multi-Armed Bandit Automated Negotiating Agent. 13th International Conference on Information and Knowledge Technology (IKT), 2022.

See Also

Paper: https://doi.org/10.1109/IKT57960.2022.10039035

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/lucky2022.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
class LuckyAgent2022(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's LuckyAgent2022.

    **ANAC 2022 Runner-up** (Individual Utility category).

    LuckyAgent2022 (developed by Arash Ebrahimnezhad) uses BOA (Bidding,
    Opponent modeling, Acceptance) components with a novel Stop-Learning
    Mechanism (SLM) adapted from multi-armed bandit theory to prevent
    overfitting.

    **Offering Strategy:**
        - Time-dependent bidding with adaptive thresholds
        - Divides target utility range into multiple goals (NUMBER_OF_GOALS=5)
        - Randomly selects from bids matching utility goals
        - Weights bid selection by estimated opponent utility
        - Uses sinusoidal variation in lower threshold for exploration

    **Acceptance Strategy:**
        - Condition 1: Offer exceeds acceptance threshold and reservation
        - Condition 2: Near deadline (t > 0.97) with offer above minimum
        - Condition 3: Weighted offer utility exceeds next planned bid utility
        - Multiple acceptance conditions increase agreement likelihood

    **Opponent Modeling:**
        Frequency-based model with Stop-Learning Mechanism:
        - Tracks opponent bids to estimate preferences
        - Uses multi-armed bandit approach to balance exploration/exploitation
        - SLM prevents overfitting by stopping learning at optimal point
        - Model used to weight bid selection toward opponent preferences

    References:
        .. [Ebrahimnezhad2022] A. Ebrahimnezhad and F. Nassiri-Mofakham,
           LuckyAgent2022: A Stop-Learning Multi-Armed Bandit Automated
           Negotiating Agent. 13th International Conference on Information
           and Knowledge Technology (IKT), 2022.

    See Also:
        Paper: https://doi.org/10.1109/IKT57960.2022.10039035

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLLuckyAgent2022

HybridAgent

negmas_negolog.HybridAgent

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's HybridAgent.

HybridAgent combines Time-Based and Behavior-Based negotiation strategies using a Bezier curve for time-based concession and weighted opponent move mirroring for behavior-based adaptation. It was developed for emotional and opponent-aware human-robot negotiation research.

Offering Strategy: Combines two strategies with time-varying weights:

  1. Time-Based (Bezier curve):
\[target_{time}(t) = (1-t)^2 p_0 + 2(1-t)t \cdot p_1 + t^2 \cdot p_2\]

where p0=1.0, p1=0.75, p2=0.55 (bounded by reservation value).

  1. Behavior-Based: Mirrors opponent concession moves using a weighted window of recent utility differences:

  2. Window weights: {1: [1], 2: [0.25, 0.75], 3: [0.11, 0.22, 0.66], 4: [0.05, 0.15, 0.3, 0.5]}

  3. Empathy parameter p3=0.5 controls response magnitude

Combined target (after first 2 rounds):

\[target = (1-t^2) \cdot target_{behavior} + t^2 \cdot target_{time}\]

This starts behavior-focused and shifts to time-based near deadline.

Acceptance Strategy: AC_Next strategy: accepts if opponent's last offer utility exceeds the current target utility. Simple but effective when combined with the hybrid target calculation.

Opponent Modeling: Implicit modeling through behavior-based component:

  • Tracks utility differences between consecutive opponent offers
  • Uses weighted window to emphasize recent moves (recent moves have higher weight)
  • Adapts own concession rate based on opponent's concession pattern
  • Empathy factor increases with time: (p3 + p3 * t)
References

.. [Keskin2021] Mehmet Onur Keskin, Umut Cakan, and Reyhan Aydogan. 2021. Solver Agent: Towards Emotional and Opponent-Aware Agent for Human-Robot Negotiation. In Proceedings of the 20th International Conference on Autonomous Agents and MultiAgent Systems (AAMAS '21). International Foundation for Autonomous Agents and Multiagent Systems, Richland, SC, 1557-1559.

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/hybrid.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
class HybridAgent(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's HybridAgent.

    HybridAgent combines Time-Based and Behavior-Based negotiation strategies
    using a Bezier curve for time-based concession and weighted opponent
    move mirroring for behavior-based adaptation. It was developed for
    emotional and opponent-aware human-robot negotiation research.

    **Offering Strategy:**
    Combines two strategies with time-varying weights:

    1. **Time-Based (Bezier curve)**:

    $$target_{time}(t) = (1-t)^2 p_0 + 2(1-t)t \cdot p_1 + t^2 \cdot p_2$$

    where p0=1.0, p1=0.75, p2=0.55 (bounded by reservation value).

    2. **Behavior-Based**: Mirrors opponent concession moves using a
    weighted window of recent utility differences:

    - Window weights: {1: [1], 2: [0.25, 0.75], 3: [0.11, 0.22, 0.66],
      4: [0.05, 0.15, 0.3, 0.5]}
    - Empathy parameter p3=0.5 controls response magnitude

    Combined target (after first 2 rounds):

    $$target = (1-t^2) \cdot target_{behavior} + t^2 \cdot target_{time}$$

    This starts behavior-focused and shifts to time-based near deadline.

    **Acceptance Strategy:**
    AC_Next strategy: accepts if opponent's last offer utility exceeds
    the current target utility. Simple but effective when combined
    with the hybrid target calculation.

    **Opponent Modeling:**
    Implicit modeling through behavior-based component:

    - Tracks utility differences between consecutive opponent offers
    - Uses weighted window to emphasize recent moves (recent moves
      have higher weight)
    - Adapts own concession rate based on opponent's concession pattern
    - Empathy factor increases with time: (p3 + p3 * t)

    References:
        .. [Keskin2021] Mehmet Onur Keskin, Umut Cakan, and Reyhan Aydogan.
           2021. Solver Agent: Towards Emotional and Opponent-Aware Agent
           for Human-Robot Negotiation. In Proceedings of the 20th
           International Conference on Autonomous Agents and MultiAgent
           Systems (AAMAS '21). International Foundation for Autonomous
           Agents and Multiagent Systems, Richland, SC, 1557-1559.

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLHybridAgent

YXAgent

negmas_negolog.YXAgent

Bases: NegologNegotiatorWrapper

NegMAS wrapper for NegoLog's YXAgent.

ANAC 2016 Individual Utility Category Runner-up.

YXAgent employs a frequency-based opponent modeling approach combined with threshold-based bidding and acceptance strategies. The agent maintains separate models for issue weights and value frequencies for each opponent, identifying the "toughest" opponent to inform its acceptance decisions.

Offering Strategy: The agent generates random bids above a threshold that is calculated based on the number of opponents (minimum 0.7). In early rounds, it offers bids with utility above a temporary threshold. After 10 rounds and before 90% of the time has elapsed, it uses the opponent model to calculate a more nuanced threshold based on the estimated utility of the opponent's last bid according to the toughest opponent's model.

Acceptance Strategy: - In early rounds (first 10) or late game (>90% time): accepts if the opponent's offer utility exceeds the temporary threshold. - During mid-game: accepts if the opponent's offer utility exceeds a calculated threshold that accounts for the opponent model's evaluation of the bid.

Opponent Modeling: YXAgent builds frequency-based models for each opponent:

- **Issue weights**: Updated when the opponent keeps the same value
  for an issue between consecutive bids, using a time-decaying formula.
- **Value frequencies**: Tracks how often each value is offered,
  normalized by the maximum frequency.
- Identifies the "hardest" (toughest) opponent based on their behavior.
References

.. [Aydogan2021] Reyhan Aydogan, Katsuhide Fujita, Tim Baarslag, Catholijn M. Jonker, and Takayuki Ito. ANAC 2017: Repeated multilateral negotiation league. In Advances in Automated Negotiations, pages 101-115, Singapore, 2021. Springer Singapore.

See Also

Paper: https://doi.org/10.1007/978-981-16-0471-3_7

Note

This description was AI-generated based on the referenced paper and source code analysis.

Source code in src/negmas_negolog/agents/yx.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
class YXAgent(NegologNegotiatorWrapper):
    """
    NegMAS wrapper for NegoLog's YXAgent.

    **ANAC 2016 Individual Utility Category Runner-up**.

    YXAgent employs a frequency-based opponent modeling approach combined with
    threshold-based bidding and acceptance strategies. The agent maintains
    separate models for issue weights and value frequencies for each opponent,
    identifying the "toughest" opponent to inform its acceptance decisions.

    **Offering Strategy:**
        The agent generates random bids above a threshold that is calculated
        based on the number of opponents (minimum 0.7). In early rounds, it
        offers bids with utility above a temporary threshold. After 10 rounds
        and before 90% of the time has elapsed, it uses the opponent model to
        calculate a more nuanced threshold based on the estimated utility of
        the opponent's last bid according to the toughest opponent's model.

    **Acceptance Strategy:**
        - In early rounds (first 10) or late game (>90% time): accepts if the
          opponent's offer utility exceeds the temporary threshold.
        - During mid-game: accepts if the opponent's offer utility exceeds a
          calculated threshold that accounts for the opponent model's
          evaluation of the bid.

    **Opponent Modeling:**
        YXAgent builds frequency-based models for each opponent:

        - **Issue weights**: Updated when the opponent keeps the same value
          for an issue between consecutive bids, using a time-decaying formula.
        - **Value frequencies**: Tracks how often each value is offered,
          normalized by the maximum frequency.
        - Identifies the "hardest" (toughest) opponent based on their behavior.

    References:
        .. [Aydogan2021] Reyhan Aydogan, Katsuhide Fujita, Tim Baarslag,
           Catholijn M. Jonker, and Takayuki Ito. ANAC 2017: Repeated
           multilateral negotiation league. In Advances in Automated
           Negotiations, pages 101-115, Singapore, 2021. Springer Singapore.

    See Also:
        Paper: https://doi.org/10.1007/978-981-16-0471-3_7

    Note:
        This description was AI-generated based on the referenced paper
        and source code analysis.
    """

    negolog_agent_class = _NLYXAgent