diff --git a/include/clients/nrt/NormalizeClient.hpp b/include/clients/nrt/NormalizeClient.hpp
index da982627c..7122641d3 100644
--- a/include/clients/nrt/NormalizeClient.hpp
+++ b/include/clients/nrt/NormalizeClient.hpp
@@ -21,8 +21,7 @@ namespace normalize {
 constexpr auto NormalizeParams = defineParameters(
     StringParam<Fixed<true>>("name", "Name"),
     FloatParam("min", "Minimum Value", 0.0),
-    FloatParam("max", "Maximum Value", 1.0),
-    EnumParam("invert", "Inverse Transform", 0, "False", "True"));
+    FloatParam("max", "Maximum Value", 1.0));
 
 class NormalizeClient : public FluidBaseClient,
                         OfflineIn,
@@ -30,7 +29,7 @@ class NormalizeClient : public FluidBaseClient,
                         ModelObject,
                         public DataClient<algorithm::Normalization>
 {
-  enum { kName, kMin, kMax, kInvert };
+  enum { kName, kMin, kMax };
 
 public:
   using string = std::string;
@@ -79,7 +78,7 @@ class NormalizeClient : public FluidBaseClient,
   MessageResult<void> transform(InputDataSetClientRef sourceClient,
                                 DataSetClientRef destClient)
   {
-    return _transform(sourceClient, destClient, get<kInvert>() == 1);
+    return _transform(sourceClient, destClient, false);
   }
 
   MessageResult<void> fitTransform(InputDataSetClientRef sourceClient,
@@ -93,22 +92,18 @@ class NormalizeClient : public FluidBaseClient,
 
   MessageResult<void> transformPoint(InputBufferPtr in, BufferPtr out)
   {
-    if (!mAlgorithm.initialized()) return Error(NoDataFitted);
-    InOutBuffersCheck bufCheck(mAlgorithm.dims());
-    if (!bufCheck.checkInputs(in.get(), out.get()))
-      return Error(bufCheck.error());
-    BufferAdaptor::Access outBuf(out.get());
-    Result                resizeResult =
-        outBuf.resize(mAlgorithm.dims(), 1, outBuf.sampleRate());
-    if (!resizeResult.ok()) return Error(BufferAlloc);
-    RealVector src(mAlgorithm.dims());
-    RealVector dest(mAlgorithm.dims());
-    src <<= BufferAdaptor::ReadAccess(in.get()).samps(0, mAlgorithm.dims(), 0);
-    mAlgorithm.setMin(get<kMin>());
-    mAlgorithm.setMax(get<kMax>());
-    mAlgorithm.processFrame(src, dest, get<kInvert>() == 1);
-    outBuf.samps(0, mAlgorithm.dims(), 0) <<= dest;
-    return OK();
+    return _transformPoint(in, out, false); 
+  }
+  
+  MessageResult<void> inverseTransform(InputDataSetClientRef sourceClient,
+                                DataSetClientRef destClient)
+  {
+    return _transform(sourceClient, destClient, true);
+  }
+  
+  MessageResult<void> inverseTransformPoint(InputBufferPtr in, BufferPtr out)
+  {
+    return _transformPoint(in, out, true); 
   }
 
   static auto getMessageDescriptors()
@@ -118,6 +113,9 @@ class NormalizeClient : public FluidBaseClient,
         makeMessage("fitTransform", &NormalizeClient::fitTransform),
         makeMessage("transform", &NormalizeClient::transform),
         makeMessage("transformPoint", &NormalizeClient::transformPoint),
+        makeMessage("inverseTransform", &NormalizeClient::inverseTransform),
+        makeMessage("inverseTransformPoint",
+                    &NormalizeClient::inverseTransformPoint),
         makeMessage("cols", &NormalizeClient::dims),
         makeMessage("clear", &NormalizeClient::clear),
         makeMessage("size", &NormalizeClient::size),
@@ -153,6 +151,27 @@ class NormalizeClient : public FluidBaseClient,
     }
     return OK();
   }
+
+  MessageResult<void> _transformPoint(InputBufferPtr in, BufferPtr out,
+                                      bool invert)
+  {
+    if (!mAlgorithm.initialized()) return Error(NoDataFitted);
+    InOutBuffersCheck bufCheck(mAlgorithm.dims());
+    if (!bufCheck.checkInputs(in.get(), out.get()))
+      return Error(bufCheck.error());
+    BufferAdaptor::Access outBuf(out.get());
+    Result                resizeResult =
+        outBuf.resize(mAlgorithm.dims(), 1, outBuf.sampleRate());
+    if (!resizeResult.ok()) return Error(BufferAlloc);
+    RealVector src(mAlgorithm.dims());
+    RealVector dest(mAlgorithm.dims());
+    src <<= BufferAdaptor::ReadAccess(in.get()).samps(0, mAlgorithm.dims(), 0);
+    mAlgorithm.setMin(get<kMin>());
+    mAlgorithm.setMax(get<kMax>());
+    mAlgorithm.processFrame(src, dest, invert);
+    outBuf.samps(0, mAlgorithm.dims(), 0) <<= dest;
+    return OK();
+  }
 };
 
 using NormalizeRef = SharedClientRef<const NormalizeClient>;
diff --git a/include/clients/nrt/RobustScaleClient.hpp b/include/clients/nrt/RobustScaleClient.hpp
index 4a6982a02..1785ab671 100644
--- a/include/clients/nrt/RobustScaleClient.hpp
+++ b/include/clients/nrt/RobustScaleClient.hpp
@@ -22,8 +22,7 @@ namespace robustscale {
 constexpr auto RobustScaleParams = defineParameters(
     StringParam<Fixed<true>>("name", "Name"),
     FloatParam("low", "Low Percentile", 25, Min(0), Max(100)),
-    FloatParam("high", "High Percentile", 75, Min(0), Max(100)),
-    EnumParam("invert", "Inverse Transform", 0, "False", "True"));
+    FloatParam("high", "High Percentile", 75, Min(0), Max(100)));
 
 class RobustScaleClient : public FluidBaseClient,
                           OfflineIn,
@@ -31,7 +30,7 @@ class RobustScaleClient : public FluidBaseClient,
                           ModelObject,
                           public DataClient<algorithm::RobustScaling>
 {
-  enum { kName, kLow, kHigh, kInvert, kInputBuffer, kOutputBuffer };
+  enum { kName, kLow, kHigh };
 
 public:
   using string = std::string;
@@ -80,7 +79,7 @@ class RobustScaleClient : public FluidBaseClient,
   MessageResult<void> transform(InputDataSetClientRef sourceClient,
                                 DataSetClientRef destClient)
   {
-    return _transform(sourceClient, destClient, get<kInvert>() == 1);
+    return _transform(sourceClient, destClient, false);
   }
 
   MessageResult<void> fitTransform(InputDataSetClientRef sourceClient,
@@ -94,20 +93,18 @@ class RobustScaleClient : public FluidBaseClient,
 
   MessageResult<void> transformPoint(InputBufferPtr in, BufferPtr out)
   {
-    if (!mAlgorithm.initialized()) return Error(NoDataFitted);
-    InOutBuffersCheck bufCheck(mAlgorithm.dims());
-    if (!bufCheck.checkInputs(in.get(), out.get()))
-      return Error(bufCheck.error());
-    BufferAdaptor::Access outBuf(out.get());
-    Result                resizeResult =
-        outBuf.resize(mAlgorithm.dims(), 1, outBuf.sampleRate());
-    if (!resizeResult.ok()) return Error(BufferAlloc);
-    RealVector src(mAlgorithm.dims());
-    RealVector dest(mAlgorithm.dims());
-    src <<= BufferAdaptor::ReadAccess(in.get()).samps(0, mAlgorithm.dims(), 0);
-    mAlgorithm.processFrame(src, dest, get<kInvert>() == 1);
-    outBuf.samps(0, mAlgorithm.dims(), 0) <<= dest;
-    return OK();
+    return _transformPoint(in, out, false);
+  }
+  
+  MessageResult<void> inverseTransform(InputDataSetClientRef sourceClient,
+                                DataSetClientRef destClient)
+  {
+    return _transform(sourceClient, destClient, true);
+  }
+  
+  MessageResult<void> inverseTransformPoint(InputBufferPtr in, BufferPtr out)
+  {
+    return _transformPoint(in, out, true);
   }
 
   static auto getMessageDescriptors()
@@ -117,6 +114,9 @@ class RobustScaleClient : public FluidBaseClient,
         makeMessage("fitTransform", &RobustScaleClient::fitTransform),
         makeMessage("transform", &RobustScaleClient::transform),
         makeMessage("transformPoint", &RobustScaleClient::transformPoint),
+        makeMessage("inverseTransform", &RobustScaleClient::inverseTransform),
+        makeMessage("inverseTransformPoint",
+                    &RobustScaleClient::inverseTransformPoint),
         makeMessage("cols", &RobustScaleClient::dims),
         makeMessage("clear", &RobustScaleClient::clear),
         makeMessage("size", &RobustScaleClient::size),
@@ -150,6 +150,25 @@ class RobustScaleClient : public FluidBaseClient,
     }
     return OK();
   }
+  
+  MessageResult<void> _transformPoint(InputBufferPtr in, BufferPtr out, bool invert)
+  {
+    if (!mAlgorithm.initialized()) return Error(NoDataFitted);
+    InOutBuffersCheck bufCheck(mAlgorithm.dims());
+    if (!bufCheck.checkInputs(in.get(), out.get()))
+      return Error(bufCheck.error());
+    BufferAdaptor::Access outBuf(out.get());
+    Result                resizeResult =
+        outBuf.resize(mAlgorithm.dims(), 1, outBuf.sampleRate());
+    if (!resizeResult.ok()) return Error(BufferAlloc);
+    RealVector src(mAlgorithm.dims());
+    RealVector dest(mAlgorithm.dims());
+    src <<= BufferAdaptor::ReadAccess(in.get()).samps(0, mAlgorithm.dims(), 0);
+    mAlgorithm.processFrame(src, dest, invert);
+    outBuf.samps(0, mAlgorithm.dims(), 0) <<= dest;
+    return OK();
+  }
+  
 };
 
 using RobustScaleRef = SharedClientRef<const RobustScaleClient>;
diff --git a/include/clients/nrt/StandardizeClient.hpp b/include/clients/nrt/StandardizeClient.hpp
index 0e647e0d9..02fb0e375 100644
--- a/include/clients/nrt/StandardizeClient.hpp
+++ b/include/clients/nrt/StandardizeClient.hpp
@@ -18,9 +18,8 @@ namespace fluid {
 namespace client {
 namespace standardize {
 
-constexpr auto StandardizeParams = defineParameters(
-    StringParam<Fixed<true>>("name", "Name"),
-    EnumParam("invert", "Inverse Transform", 0, "False", "True"));
+constexpr auto StandardizeParams =
+    defineParameters(StringParam<Fixed<true>>("name", "Name"));
 
 class StandardizeClient : public FluidBaseClient,
                           OfflineIn,
@@ -28,7 +27,7 @@ class StandardizeClient : public FluidBaseClient,
                           ModelObject,
                           public DataClient<algorithm::Standardization>
 {
-  enum { kName, kInvert, kInputBuffer, kOutputBuffer };
+  enum { kName };
 
 public:
   using string = std::string;
@@ -78,25 +77,23 @@ class StandardizeClient : public FluidBaseClient,
   MessageResult<void> transform(InputDataSetClientRef sourceClient,
                                 DataSetClientRef destClient) const
   {
-    return _transform(sourceClient, destClient, get<kInvert>() == 1);
+    return _transform(sourceClient, destClient, false);
   }
 
   MessageResult<void> transformPoint(InputBufferPtr in, BufferPtr out) const
   {
-    if (!mAlgorithm.initialized()) return Error(NoDataFitted);
-    InOutBuffersCheck bufCheck(mAlgorithm.dims());
-    if (!bufCheck.checkInputs(in.get(), out.get()))
-      return Error(bufCheck.error());
-    BufferAdaptor::Access outBuf(out.get());
-    Result                resizeResult =
-        outBuf.resize(mAlgorithm.dims(), 1, outBuf.sampleRate());
-    if (!resizeResult.ok()) return Error(BufferAlloc);
-    RealVector src(mAlgorithm.dims());
-    RealVector dest(mAlgorithm.dims());
-    src <<= BufferAdaptor::ReadAccess(in.get()).samps(0, mAlgorithm.dims(), 0);
-    mAlgorithm.processFrame(src, dest, get<kInvert>() == 1);
-    outBuf.samps(0, mAlgorithm.dims(), 0) <<= dest;
-    return OK();
+     return _transformPoint(in,out,false);
+  }
+
+  MessageResult<void> inverseTransform(InputDataSetClientRef sourceClient,
+                                DataSetClientRef destClient) const
+  {
+    return _transform(sourceClient, destClient, true);
+  }
+
+  MessageResult<void> inverseTransformPoint(InputBufferPtr in, BufferPtr out) const
+  {
+    return _transformPoint(in,out,true);
   }
 
   MessageResult<void> fitTransform(InputDataSetClientRef sourceClient,
@@ -115,6 +112,9 @@ class StandardizeClient : public FluidBaseClient,
         makeMessage("fitTransform", &StandardizeClient::fitTransform),
         makeMessage("transform", &StandardizeClient::transform),
         makeMessage("transformPoint", &StandardizeClient::transformPoint),
+        makeMessage("inverseTransform", &StandardizeClient::inverseTransform),
+        makeMessage("inverseTransformPoint",
+                    &StandardizeClient::inverseTransformPoint),
         makeMessage("cols", &StandardizeClient::dims),
         makeMessage("clear", &StandardizeClient::clear),
         makeMessage("size", &StandardizeClient::size),
@@ -148,6 +148,25 @@ class StandardizeClient : public FluidBaseClient,
     }
     return OK();
   }
+  
+  MessageResult<void> _transformPoint(InputBufferPtr in, BufferPtr out, bool invert) const
+  {
+    if (!mAlgorithm.initialized()) return Error(NoDataFitted);
+    InOutBuffersCheck bufCheck(mAlgorithm.dims());
+    if (!bufCheck.checkInputs(in.get(), out.get()))
+      return Error(bufCheck.error());
+    BufferAdaptor::Access outBuf(out.get());
+    Result                resizeResult =
+        outBuf.resize(mAlgorithm.dims(), 1, outBuf.sampleRate());
+    if (!resizeResult.ok()) return Error(BufferAlloc);
+    RealVector src(mAlgorithm.dims());
+    RealVector dest(mAlgorithm.dims());
+    src <<= BufferAdaptor::ReadAccess(in.get()).samps(0, mAlgorithm.dims(), 0);
+    mAlgorithm.processFrame(src, dest, invert);
+    outBuf.samps(0, mAlgorithm.dims(), 0) <<= dest;
+    return OK();
+  }
+  
 };
 
 using StandardizeRef = SharedClientRef<const StandardizeClient>;