Modelling risk aversion How would you model risk aversion in an automated planner?
This section in Planning Algorithms, briefly talks about this, but doesn't really describe a solution. However, example 4 is an interesting scenario:
Suppose that you have performed the task and are about to win the prize.
Just to add to the drama, the host offers you a gambling opportunity. You
can select action u1 and receive $10,000, or be a gambler by selecting u2 
and have probability 1/2 of winning $25,000 by the tossing of a fair coin.
In terms of the expected reward, the clear choice is u2 . However, you just
completed the unpleasant task and expect to earn money. The risk of losing
it all may be intolerable. Different people will have different preferences
in this situation.

So in this case, the agent has choice u1=10000*1.0=10000, or u2=25000*0.5=12500
Now supposed the agent accumulated $500 in expenses in order to arrive at this scenario, and needs to at least break even. How would you model two different agents, one that's extremely risk-averse and so would always choose u1, since it gaurantees it'll cover its costs, and another agent that's more reckless and so would always choose u2, even though there's a greater chance of it getting nothing?
This is some very crude Python to model out the classical utility-based approach, and one that I think answers my question:
#!/usr/bin/env python

expenses = 500
u1 = (10000, 1.0)
u2 = (25000, 0.5)
actions = [u1, u2]

def decide_utility(actions):
    choices = [(r*p, i) for i,(r,p) in enumerate(actions)]
    best = max(choices)
    return best[1]+1

def decide_risk(actions, expenses, risk_factor):
    choices = [((p if r>=expenses else 0.0)*risk_factor, i) for i,(r,p) in enumerate(actions)]
    best = max(choices)
    return best[1]+1

print decide_utility(actions) # chooses u2
print decide_risk(actions, expenses, risk_factor=1.0) # risk-averse, chooses u1
print decide_risk(actions, expenses, risk_factor=0.0) # risk-prone, chooses u2

Does this make sense? Is there a better way to do this?
 A: The standard approach (in microeconomics) is to model agents as maximizing (subjective) expected utility. Depending on the utility function, they will then choose differently.
The expected utility for the two options in this example is (w=wealth, c1= first option, c2=second option, u(.) a utility function):
E_c1[ u(w) ] = u(w+10000-500)
E_c2[ u(w) ] = 0.5*u(w+25000-500)+0.5*u(w-500)
Whichever is greater is what the agent would choose..it depends on the utility function.
There are many you could choose from (but they need to satisfy certain properties, see here:http://en.wikipedia.org/wiki/Von_Neumann%E2%80%93Morgenstern_utility_theorem). 
In general they are classified into risk neutral, risk averse and risk loving for linear, concave and convex utility functions respectively. How risk averse/risk loving an agent is depends on how concave/convex the utility function is. An intuitive measure of risk aversion is actually how expected profit you'd be willing to give up to secure a sure thing, if you opt for the first choice here, that would be 2500. In the econ jargon that's your "certainty equivalent" of the lottery u2. If the certainty equivalent is less than the expected value, you're risk averse.
