Use a custom (named) function:

def std(x):
    return x.std(ddof=0)

df.groupby('a').agg({'b': ['sum', 'mean', std]})

Or functools.partial:

from functools import partial

df.groupby('a').agg({'b': ['sum', 'mean', partial(pd.Series.std, ddof=0)]})

Output:

    b          
  sum mean  std
a              
1   9  4.5  0.5
2   6  6.0  0.0

overhead of a custom function

Using a custom function is a bit slower, but still quite reasonable:

np.random.seed(0)
n = 1_000_000
df = pd.DataFrame({'a': np.random.randint(0, 100, n),
                   'b': np.random.random(n)
                  })

%timeit df.groupby('a').agg({'b': ['std']})
# 15.4 ms ± 378 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit df.groupby('a').agg({'b': [std]})
# 38.6 ms ± 3 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit df.groupby('a').agg({'b': [partial(pd.Series.std, ddof=0)]})
# 39.3 ms ± 2.05 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

This is no longer true for a huge number of groups (e.g. 100k), in this case the difference is 33.3 ms ± 3.54 ms vs 2.07 s ± 57.3 ms.

changing the default value

Another option, if you really have a huge number of rows you could temporarily change the default parameters of pandas.core.groupby.SeriesGroupBy.std:

defaults = pd.core.groupby.SeriesGroupBy.std.__defaults__

pd.core.groupby.SeriesGroupBy.std.__defaults__ = (0, None, None, False)
out = df.groupby('a').agg({'b': ['sum', 'mean', 'std']})
pd.core.groupby.SeriesGroupBy.std.__defaults__ = defaults

Output:

    b          
  sum mean  std
a              
1   9  4.5  0.5
2   6  6.0  0.0

Timings:

pd.core.groupby.SeriesGroupBy.std.__defaults__ = (1, None, None, False)
%timeit df.groupby('a').agg({'b': ['std']})
# 31.4 ms ± 956 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

pd.core.groupby.SeriesGroupBy.std.__defaults__ = (0, None, None, False)
%timeit df.groupby('a').agg({'b': ['std']})
# 30.3 ms ± 355 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

Or defining a copy of the std method with new default parameters (see this answer for how to copy the method):

import types

def copy_func(f, defaults=None):
    '''
    return a function with same code, globals, defaults, and closure
    (or provide new defaults)
    '''
    fn = types.FunctionType(f.__code__, f.__globals__, f.__name__,
                            defaults or f.__defaults__, f.__closure__)
    # in case f was given attrs (note this dict is a shallow copy):
    fn.__dict__.update(f.__dict__) 
    return fn


pd.core.groupby.SeriesGroupBy.std0 = copy_func(pd.core.groupby.SeriesGroupBy.std,
                                               defaults=(0, None, None, False))

df.groupby('a').agg({'b': ['std', 'std0']})