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']})

pandas uses the Unbiased estimation by default and numpy does not by default, So neither of them are incorrect they use different approach to calculate std
To make numpy use Unbiased estimation pass ddof=1 to std

>>> import numpy
>>> import pandas

>>> df = pandas.DataFrame(numpy.random.rand(100))

>>> numpy.std(df[0]) #default std biased estimation
0.2877601644414916

>>> numpy.std(df[0],ddof=1) #with ddof=1 i.e unbiased estimation
0.2892098469889083

>>> df[0].std() # unbiased estimation match with numpy std with ddof=1
0.2892098469889083