diff --git a/src/Platform/Microsoft.Testing.Platform/Requests/TreeNodeFilter/FilterOperator.cs b/src/Platform/Microsoft.Testing.Platform/Requests/TreeNodeFilter/FilterOperator.cs
index 9743f49f87..d518d7548f 100644
--- a/src/Platform/Microsoft.Testing.Platform/Requests/TreeNodeFilter/FilterOperator.cs
+++ b/src/Platform/Microsoft.Testing.Platform/Requests/TreeNodeFilter/FilterOperator.cs
@@ -19,9 +19,4 @@ internal enum FilterOperator
     /// Combine the following expressions with a logical OR.
     /// </summary>
     Or,
-
-    /// <summary>
-    /// Filter the following expression by the given property.
-    /// </summary>
-    Equals,
 }
diff --git a/src/Platform/Microsoft.Testing.Platform/Requests/TreeNodeFilter/OperatorKind.cs b/src/Platform/Microsoft.Testing.Platform/Requests/TreeNodeFilter/OperatorKind.cs
index 051583489c..b9c7da2819 100644
--- a/src/Platform/Microsoft.Testing.Platform/Requests/TreeNodeFilter/OperatorKind.cs
+++ b/src/Platform/Microsoft.Testing.Platform/Requests/TreeNodeFilter/OperatorKind.cs
@@ -41,6 +41,11 @@ internal enum OperatorKind
     /// </summary>
     FilterEquals,
 
+    /// <summary>
+    /// Filter not equals operator.
+    /// </summary>
+    FilterNotEquals,
+
     /// <summary>
     /// Operator used for combining multiple filters with a logical OR.
     /// </summary>
diff --git a/src/Platform/Microsoft.Testing.Platform/Requests/TreeNodeFilter/TreeNodeFilter.cs b/src/Platform/Microsoft.Testing.Platform/Requests/TreeNodeFilter/TreeNodeFilter.cs
index 9bec02318e..9a81e683df 100644
--- a/src/Platform/Microsoft.Testing.Platform/Requests/TreeNodeFilter/TreeNodeFilter.cs
+++ b/src/Platform/Microsoft.Testing.Platform/Requests/TreeNodeFilter/TreeNodeFilter.cs
@@ -38,6 +38,7 @@ internal TreeNodeFilter(string filter)
     /// FILTER_EXPR =
     ///   '(' FILTER_EXPR ')'
     ///   | TOKEN '=' TOKEN
+    ///   | TOKEN '!=' TOKEN
     ///   | FILTER_EXPR OP FILTER_EXPR
     ///   | TOKEN
     /// OP = '&amp;' | '|'
@@ -210,6 +211,13 @@ private static List<FilterExpression> ParseFilter(string filter)
                     isPropAllowed = false;
                     break;
 
+                case "!=":
+                    operatorStack.Push(OperatorKind.FilterNotEquals);
+
+                    isOperatorAllowed = false;
+                    isPropAllowed = false;
+                    break;
+
                 default:
                     expressionStack.Push(new ValueExpression(token));
 
@@ -311,7 +319,6 @@ private static void ProcessStackOperator(OperatorKind op, Stack<FilterExpression
                 {
                     OperatorKind.And => FilterOperator.And,
                     OperatorKind.Or => FilterOperator.Or,
-                    OperatorKind.FilterEquals => FilterOperator.Equals,
                     _ => throw ApplicationStateGuard.Unreachable(),
                 };
 
@@ -319,6 +326,7 @@ private static void ProcessStackOperator(OperatorKind op, Stack<FilterExpression
                 break;
 
             case OperatorKind.FilterEquals:
+            case OperatorKind.FilterNotEquals:
                 FilterExpression valueExpr = expr.Pop();
                 FilterExpression propExpr = expr.Pop();
 
@@ -328,7 +336,13 @@ private static void ProcessStackOperator(OperatorKind op, Stack<FilterExpression
                     throw new InvalidOperationException();
                 }
 
-                expr.Push(new PropertyExpression(propValueExpr, valueValueExpr));
+                FilterExpression filterExpression = new PropertyExpression(propValueExpr, valueValueExpr);
+                if (op == OperatorKind.FilterNotEquals)
+                {
+                    filterExpression = new OperatorExpression(FilterOperator.Not, [filterExpression]);
+                }
+
+                expr.Push(filterExpression);
                 break;
 
             default:
@@ -407,6 +421,25 @@ private static IEnumerable<string> TokenizeFilter(string filter)
 
                     break;
 
+                case '!':
+                    if (i + 1 < filter.Length && filter[i + 1] == '=')
+                    {
+                        if (lastStringTokenBuilder.Length > 0)
+                        {
+                            yield return lastStringTokenBuilder.ToString();
+                            lastStringTokenBuilder.Clear();
+                        }
+
+                        yield return "!=";
+                        i++;
+                    }
+                    else
+                    {
+                        goto default;
+                    }
+
+                    break;
+
                 default:
                     lastStringTokenBuilder.Append(Regex.Escape(filter[i].ToString()));
                     break;
diff --git a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Requests/TreeNodeFilterTests.cs b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Requests/TreeNodeFilterTests.cs
index f07a899ae9..f587f02457 100644
--- a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Requests/TreeNodeFilterTests.cs
+++ b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Requests/TreeNodeFilterTests.cs
@@ -105,6 +105,42 @@ public void Parameters_PropertyCheck()
         Assert.IsFalse(filter.MatchesFilter("/ProjectB.UnitTests", new PropertyBag()));
     }
 
+    [TestMethod]
+    public void Parameters_NegatedPropertyCheck()
+    {
+        TreeNodeFilter filter = new("/*.UnitTests[Tag!=Fast]");
+        Assert.IsFalse(filter.MatchesFilter("/ProjectB.UnitTests", new PropertyBag(new KeyValuePairStringProperty("Tag", "Fast"))));
+        Assert.IsTrue(filter.MatchesFilter("/ProjectB.UnitTests", new PropertyBag(new KeyValuePairStringProperty("Tag", "Slow"))));
+        Assert.IsTrue(filter.MatchesFilter("/ProjectB.UnitTests", new PropertyBag()));
+    }
+
+    [TestMethod]
+    public void Parameters_NegatedPropertyCheckWithMatchAllFilter()
+    {
+        TreeNodeFilter filter = new("/**[Tag!=Fast]");
+        Assert.IsFalse(filter.MatchesFilter("/ProjectB.UnitTests", new PropertyBag(new KeyValuePairStringProperty("Tag", "Fast"))));
+        Assert.IsTrue(filter.MatchesFilter("/ProjectB.UnitTests", new PropertyBag(new KeyValuePairStringProperty("Tag", "Slow"))));
+        Assert.IsTrue(filter.MatchesFilter("/ProjectB.UnitTests", new PropertyBag()));
+    }
+
+    [TestMethod]
+    public void Parameters_NegatedPropertyCheckCombinedWithAnd()
+    {
+        TreeNodeFilter filter = new("/*.UnitTests[(Tag!=Fast)&(Tag!=Slow)]");
+        Assert.IsFalse(filter.MatchesFilter("/ProjectB.UnitTests", new PropertyBag(new KeyValuePairStringProperty("Tag", "Fast"))));
+        Assert.IsFalse(filter.MatchesFilter("/ProjectB.UnitTests", new PropertyBag(new KeyValuePairStringProperty("Tag", "Slow"))));
+        Assert.IsTrue(filter.MatchesFilter("/ProjectB.UnitTests", new PropertyBag()));
+    }
+
+    [TestMethod]
+    public void Parameters_NegatedPropertyCheckCombinedWithOr()
+    {
+        TreeNodeFilter filter = new("/*.UnitTests[(Tag!=Fast)|(Tag!=Slow)]");
+        Assert.IsTrue(filter.MatchesFilter("/ProjectB.UnitTests", new PropertyBag(new KeyValuePairStringProperty("Tag", "Fast"))));
+        Assert.IsTrue(filter.MatchesFilter("/ProjectB.UnitTests", new PropertyBag(new KeyValuePairStringProperty("Tag", "Slow"))));
+        Assert.IsTrue(filter.MatchesFilter("/ProjectB.UnitTests", new PropertyBag()));
+    }
+
     [TestMethod]
     public void Parameters_DisallowAtStart()
         => Assert.ThrowsException<InvalidOperationException>(() => _ = new TreeNodeFilter("/[Tag=Fast]"));