diff --git a/Doc/library/inspect.rst b/Doc/library/inspect.rst
index fb92783..5ece3cd 100644
--- a/Doc/library/inspect.rst
+++ b/Doc/library/inspect.rst
@@ -307,6 +307,12 @@
 
    Return true if the object is a user-defined or built-in function or method.
 
+.. function:: isabstract(object)
+
+   Return true if the object is an abstract base class.
+
+   .. versionadded:: 2.6
+
 
 .. function:: ismethoddescriptor(object)
 
diff --git a/Lib/inspect.py b/Lib/inspect.py
index 42f2c31..3f9199f 100644
--- a/Lib/inspect.py
+++ b/Lib/inspect.py
@@ -38,11 +38,15 @@
 import imp
 import tokenize
 import linecache
+from abc import ABCMeta
 from operator import attrgetter
 from collections import namedtuple
 from compiler.consts import (CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS,
     CO_VARKEYWORDS, CO_GENERATOR)
 
+# See Include/object.h
+TPFLAGS_IS_ABSTRACT = 1 << 20
+
 # ----------------------------------------------------------- type-checking
 def ismodule(object):
     """Return true if the object is a module.
@@ -241,6 +245,10 @@
     """Return true if the object is a generator object."""
     return isinstance(object, types.GeneratorType)
 
+def isabstract(object):
+    """Return true if the object is an abstract base class (ABC)."""
+    return object.__flags__ & TPFLAGS_IS_ABSTRACT
+
 def getmembers(object, predicate=None):
     """Return all members of an object as (name, value) pairs sorted by name.
     Optionally, only return members that satisfy a given predicate."""
diff --git a/Lib/test/regrtest.py b/Lib/test/regrtest.py
index b6aa96b..dfb01ba 100755
--- a/Lib/test/regrtest.py
+++ b/Lib/test/regrtest.py
@@ -129,6 +129,7 @@
 import re
 import cStringIO
 import traceback
+from inspect import isabstract
 
 # I see no other way to suppress these warnings;
 # putting them in test_grammar.py has no effect:
@@ -649,7 +650,6 @@
 def dash_R(the_module, test, indirect_test, huntrleaks):
     # This code is hackish and inelegant, but it seems to do the job.
     import copy_reg, _abcoll
-    from abc import _Abstract
 
     if not hasattr(sys, 'gettotalrefcount'):
         raise Exception("Tracking reference leaks requires a debug build "
@@ -661,7 +661,7 @@
     pic = sys.path_importer_cache.copy()
     abcs = {}
     for abc in [getattr(_abcoll, a) for a in _abcoll.__all__]:
-        if not issubclass(abc, _Abstract):
+        if not isabstract(abc):
             continue
         for obj in abc.__subclasses__() + [abc]:
             abcs[obj] = obj._abc_registry.copy()
@@ -699,7 +699,6 @@
     import _strptime, linecache, dircache
     import urlparse, urllib, urllib2, mimetypes, doctest
     import struct, filecmp, _abcoll
-    from abc import _Abstract
     from distutils.dir_util import _path_created
 
     # Restore some original values.
@@ -714,7 +713,7 @@
 
     # Clear ABC registries, restoring previously saved ABC registries.
     for abc in [getattr(_abcoll, a) for a in _abcoll.__all__]:
-        if not issubclass(abc, _Abstract):
+        if not isabstract(abc):
             continue
         for obj in abc.__subclasses__() + [abc]:
             obj._abc_registry = abcs.get(obj, {}).copy()
diff --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py
index c53dcea..f1c0c3b 100644
--- a/Lib/test/test_abc.py
+++ b/Lib/test/test_abc.py
@@ -7,6 +7,7 @@
 from test import test_support
 
 import abc
+from inspect import isabstract
 
 
 class TestABC(unittest.TestCase):
@@ -43,19 +44,23 @@
                 def bar(self): pass  # concrete
             self.assertEqual(C.__abstractmethods__, set(["foo"]))
             self.assertRaises(TypeError, C)  # because foo is abstract
+            self.assert_(isabstract(C))
             class D(C):
                 def bar(self): pass  # concrete override of concrete
             self.assertEqual(D.__abstractmethods__, set(["foo"]))
             self.assertRaises(TypeError, D)  # because foo is still abstract
+            self.assert_(isabstract(D))
             class E(D):
                 def foo(self): pass
             self.assertEqual(E.__abstractmethods__, set())
             E()  # now foo is concrete, too
+            self.failIf(isabstract(E))
             class F(E):
                 @abstractthing
                 def bar(self): pass  # abstract override of concrete
             self.assertEqual(F.__abstractmethods__, set(["bar"]))
             self.assertRaises(TypeError, F)  # because bar is abstract now
+            self.assert_(isabstract(F))
 
     def test_subclass_oldstyle_class(self):
         class A:
diff --git a/Misc/NEWS b/Misc/NEWS
index 208c350..43785cc 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -447,6 +447,8 @@
 Library
 -------
 
+- Add inspect.isabstract(object) to fix bug #2223
+
 - Add a __format__ method to Decimal, to support PEP 3101.
 
 - Add a timing parameter when using trace.Trace to print out timestamps.