diff --git a/README.rst b/README.rst
index 4b0de7f952c4c87ef2926eaba5e2c4b76d2f902e..a90c0ff63b8c14999bd35a22f17378e891b28dc1 100644
--- a/README.rst
+++ b/README.rst
@@ -268,6 +268,10 @@ Check if the function was ever called with certain arguments
     self.assertSpyLastCalledWith(obj.function, 'foo', bar='baz')
     self.assertTrue(obj.function.last_called_with('foo', bar='baz'))
 
+    # Or the inverse:
+    self.assertSpyNotCalledWith(obj.function, 'foo', bar='baz')
+    self.assertFalse(obj.function.called)
+
 
 The whole call history will be searched. You can provide the entirety of the
 arguments passed to the function, or you can provide a subset. You can pass
diff --git a/kgb/agency.py b/kgb/agency.py
index 0852b0ed9342a1ce51b408875cde5ec2b1d901fc..d1cc18bef33b9a417e14bff44e05f714f420340a 100644
--- a/kgb/agency.py
+++ b/kgb/agency.py
@@ -309,6 +309,60 @@ class SpyAgency(object):
                             self._format_spy_call_args),
                     ))
 
+    def assertSpyNotCalledWith(self, spy_or_call, *expected_args,
+                               **expected_kwargs):
+        """Assert that a function was not called with the given arguments.
+
+        If a spy is provided, all calls will be checked for a match.
+
+        This will imply :py:meth:`assertHasSpy`.
+
+        Args:
+            spy_or_call (callable or kgb.spies.FunctionSpy):
+                The function, spy, or call to check.
+
+            *expected_args (tuple):
+                Position arguments not expected to be provided in any of the
+                calls.
+
+            **expected_kwargs (dict):
+                Keyword arguments not expected to be provided in any of the
+                calls.
+
+        Raises:
+            AssertionError:
+                The function was called with the provided arguments.
+        """
+        if isinstance(spy_or_call, FunctionSpy):
+            self.assertSpyCalled(spy_or_call)
+
+        if spy_or_call.called_with(*expected_args, **expected_kwargs):
+            if isinstance(spy_or_call, SpyCall):
+                self._kgb_assert_fail(
+                    'This call to %s was unexpectedly passed args=%s, '
+                    'kwargs=%s.'
+                    % (
+                        self._format_spy_or_call(spy_or_call),
+                        safe_repr(expected_args),
+                        self._format_spy_kwargs(expected_kwargs),
+                    ))
+            else:
+                self._kgb_assert_fail(
+                    'A call to %s was unexpectedly passed args=%s, '
+                    'kwargs=%s.\n'
+                    '\n'
+                    'The following calls were recorded:\n'
+                    '\n'
+                    '%s'
+                    % (
+                        self._format_spy_or_call(spy_or_call),
+                        safe_repr(expected_args),
+                        self._format_spy_kwargs(expected_kwargs),
+                        self._format_spy_calls(
+                            spy_or_call,
+                            self._format_spy_call_args),
+                    ))
+
     def assertSpyLastCalledWith(self, spy, *expected_args, **expected_kwargs):
         """Assert that a function was last called with the given arguments.
 
diff --git a/kgb/tests/test_spy_agency.py b/kgb/tests/test_spy_agency.py
index 07600f594b6726255c9222493ad28208d35f1015..94f58753944a5042e8b6b39b5889e938c044f25c 100644
--- a/kgb/tests/test_spy_agency.py
+++ b/kgb/tests/test_spy_agency.py
@@ -278,6 +278,60 @@ class TestCaseMixinTests(SpyAgency, TestCase):
         with self._check_assertion(msg):
             self.assertSpyCalledWith(obj.do_math.spy.calls[0], x=4, z=1)
 
+    def test_assertSpyNotCalledWith_with_unexpected_arguments(self):
+        """Testing SpyAgency.assertSpyNotCalledWith with unexpected arguments
+        """
+        obj = MathClass()
+        self.spy_on(obj.do_math)
+
+        obj.do_math(1, b=4)
+        obj.do_math(2, b=9)
+
+        # These should not fail.
+        self.assertSpyNotCalledWith(obj.do_math, a=1, b=3)
+        self.assertSpyNotCalledWith(obj.do_math.calls[0], a=1, b=3)
+        self.assertSpyNotCalledWith(obj.do_math.spy, a=1, b=9)
+        self.assertSpyNotCalledWith(obj.do_math.spy.calls[1], a=1, b=9)
+
+    def test_assertSpyNotCalledWith_without_unexpected_arguments(self):
+        """Testing SpyAgency.assertSpyNotCalledWith without unexpected
+        arguments
+        """
+        obj = MathClass()
+        self.spy_on(obj.do_math)
+
+        obj.do_math(1, b=4)
+        obj.do_math(2, b=9)
+
+        msg = (
+            "A call to do_math was unexpectedly passed args=(), "
+            "kwargs={'a': 1, 'b': 4}.\n"
+            "\n"
+            "The following calls were recorded:\n"
+            "\n"
+            "Call 0:\n"
+            "  args=()\n"
+            "  kwargs={'a': 1, 'b': 4}\n"
+            "\n"
+            "Call 1:\n"
+            "  args=()\n"
+            "  kwargs={'a': 2, 'b': 9}"
+        )
+
+        with self._check_assertion(msg):
+            self.assertSpyNotCalledWith(obj.do_math, a=1, b=4)
+
+        with self._check_assertion(msg):
+            self.assertSpyNotCalledWith(obj.do_math.spy, a=1, b=4)
+
+        msg = (
+            "This call to do_math was unexpectedly passed args=(),"
+            " kwargs={'a': 2, 'b': 9}."
+        )
+
+        with self._check_assertion(msg):
+            self.assertSpyNotCalledWith(obj.do_math.spy.calls[1], a=2, b=9)
+
     def test_assertSpyLastCalledWith_with_expected_arguments(self):
         """Testing SpyAgency.assertSpyLastCalledWith with expected arguments"""
         obj = MathClass()