diff --git a/src/XrdCl/XrdClFileOperations.hh b/src/XrdCl/XrdClFileOperations.hh
index d9c0e6af867..d17269a98cb 100644
--- a/src/XrdCl/XrdClFileOperations.hh
+++ b/src/XrdCl/XrdClFileOperations.hh
@@ -34,7 +34,7 @@ namespace XrdCl
 {
 
   template<template<State> class Derived, State state, typename ... Arguments>
-  class FileOperation: public OperationBase<Derived, state, Arguments...>
+  class FileOperation: public ConcreteOperation<Derived, state, Arguments...>
   {
 
       template<template<State> class, State, typename ...> friend class FileOperation;
@@ -51,7 +51,7 @@ namespace XrdCl
       }
 
       template<State from>
-      FileOperation( FileOperation<Derived, from, Arguments...> && op ) : OperationBase<Derived, state, Arguments...>( std::move( op ) ), file( op.file )
+      FileOperation( FileOperation<Derived, from, Arguments...> && op ) : ConcreteOperation<Derived, state, Arguments...>( std::move( op ) ), file( op.file )
       {
 
       }
@@ -113,12 +113,12 @@ namespace XrdCl
       OpenImpl<Configured> operator()( Arg<std::string> url,
           Arg<OpenFlags::Flags> flags, Arg<Access::Mode> mode = Access::None )
       {
-        return this->OperationBase<OpenImpl, state, Arg<std::string>,
+        return this->ConcreteOperation<OpenImpl, state, Arg<std::string>,
             Arg<OpenFlags::Flags>, Arg<Access::Mode>>::operator ()(
             std::move( url ), std::move( flags ), std::move( mode ) );
       }
 
-      using OperationBase<OpenImpl, state, Arg<std::string>,
+      using ConcreteOperation<OpenImpl, state, Arg<std::string>,
           Arg<OpenFlags::Flags>, Arg<Access::Mode>>::operator>>;
 
       OpenImpl<Handled> operator>>(
@@ -223,7 +223,7 @@ namespace XrdCl
           typedef void* type;
       };
 
-      using OperationBase<ReadImpl, state, Arg<uint64_t>, Arg<uint32_t>,
+      using ConcreteOperation<ReadImpl, state, Arg<uint64_t>, Arg<uint32_t>,
           Arg<void*>>::operator>>;
 
       ReadImpl<Handled> operator>>(
@@ -293,7 +293,7 @@ namespace XrdCl
 
       }
 
-      using OperationBase<CloseImpl, state>::operator>>;
+      using ConcreteOperation<CloseImpl, state>::operator>>;
 
       CloseImpl<Handled> operator>>(
           std::function<void( XRootDStatus& )> handleFunction )
@@ -351,7 +351,7 @@ namespace XrdCl
           typedef bool type;
       };
 
-      using OperationBase<StatImpl, state, Arg<bool>>::operator>>;
+      using ConcreteOperation<StatImpl, state, Arg<bool>>::operator>>;
 
       StatImpl<Handled> operator>>(
           std::function<void( XRootDStatus&, StatInfo& )> handleFunction )
@@ -439,7 +439,7 @@ namespace XrdCl
           typedef void* type;
       };
 
-      using OperationBase<WriteImpl, state, Arg<uint64_t>, Arg<uint32_t>,
+      using ConcreteOperation<WriteImpl, state, Arg<uint64_t>, Arg<uint32_t>,
           Arg<void*>>::operator>>;
 
       WriteImpl<Handled> operator>>(
@@ -505,7 +505,7 @@ namespace XrdCl
       {
       }
 
-      using OperationBase<SyncImpl, state>::operator>>;
+      using ConcreteOperation<SyncImpl, state>::operator>>;
 
       SyncImpl<Handled> operator>>(
           std::function<void( XRootDStatus& )> handleFunction )
@@ -563,7 +563,7 @@ namespace XrdCl
           typedef uint64_t type;
       };
 
-      using OperationBase<TruncateImpl, state, Arg<uint64_t>>::operator>>;
+      using ConcreteOperation<TruncateImpl, state, Arg<uint64_t>>::operator>>;
 
       TruncateImpl<Handled> operator>>(
           std::function<void( XRootDStatus& )> handleFunction )
@@ -642,7 +642,7 @@ namespace XrdCl
           typedef char* type;
       };
 
-      using OperationBase<VectorReadImpl, state, Arg<ChunkList>, Arg<void*>>::operator>>;
+      using ConcreteOperation<VectorReadImpl, state, Arg<ChunkList>, Arg<void*>>::operator>>;
 
       VectorReadImpl<Handled> operator>>(
           std::function<void( XRootDStatus& )> handleFunction )
@@ -714,7 +714,7 @@ namespace XrdCl
           typedef ChunkList type;
       };
 
-      using OperationBase<VectorWriteImpl, state, Arg<ChunkList>>::operator>>;
+      using ConcreteOperation<VectorWriteImpl, state, Arg<ChunkList>>::operator>>;
 
       VectorWriteImpl<Handled> operator>>(
           std::function<void( XRootDStatus& )> handleFunction )
@@ -799,7 +799,7 @@ namespace XrdCl
           typedef int type;
       };
 
-      using OperationBase<WriteVImpl, state, Arg<uint64_t>, Arg<struct iovec*>,
+      using ConcreteOperation<WriteVImpl, state, Arg<uint64_t>, Arg<struct iovec*>,
           Arg<int>>::operator>>;
 
       WriteVImpl<Handled> operator>>(
@@ -872,7 +872,7 @@ namespace XrdCl
           typedef Buffer type;
       };
 
-      using OperationBase<FcntlImpl, state, Arg<Buffer>>::operator>>;
+      using ConcreteOperation<FcntlImpl, state, Arg<Buffer>>::operator>>;
 
       FcntlImpl<Handled> operator>>(
           std::function<void( XRootDStatus&, Buffer& )> handleFunction )
@@ -931,7 +931,7 @@ namespace XrdCl
       {
       }
 
-      using OperationBase<VisaImpl, state>::operator>>;
+      using ConcreteOperation<VisaImpl, state>::operator>>;
 
       VisaImpl<Handled> operator>>(
           std::function<void( XRootDStatus&, Buffer& )> handleFunction )
diff --git a/src/XrdCl/XrdClFileSystemOperations.hh b/src/XrdCl/XrdClFileSystemOperations.hh
index 37290ff6236..87bdf001369 100644
--- a/src/XrdCl/XrdClFileSystemOperations.hh
+++ b/src/XrdCl/XrdClFileSystemOperations.hh
@@ -34,7 +34,7 @@ namespace XrdCl
 {
 
   template<template<State> class Derived, State state, typename ... Args>
-  class FileSystemOperation: public OperationBase<Derived, state, Args...>
+  class FileSystemOperation: public ConcreteOperation<Derived, state, Args...>
   {
 
       template<template<State> class, State, typename ...> friend class FileSystemOperation;
@@ -52,7 +52,7 @@ namespace XrdCl
       }
 
       template<State from>
-      FileSystemOperation( FileSystemOperation<Derived, from, Args...> && op ): OperationBase<Derived, state, Args...>( std::move( op ) ), filesystem( op.filesystem )
+      FileSystemOperation( FileSystemOperation<Derived, from, Args...> && op ): ConcreteOperation<Derived, state, Args...>( std::move( op ) ), filesystem( op.filesystem )
       {}
 
       virtual ~FileSystemOperation()
@@ -100,7 +100,7 @@ namespace XrdCl
           typedef OpenFlags::Flags type;
       };
 
-      using OperationBase<LocateImpl, state, Arg<std::string>,
+      using ConcreteOperation<LocateImpl, state, Arg<std::string>,
           Arg<OpenFlags::Flags>>::operator>>;
 
       LocateImpl<Handled> operator>>(
@@ -181,7 +181,7 @@ namespace XrdCl
           typedef OpenFlags::Flags type;
       };
 
-      using OperationBase<DeepLocateImpl, state, Arg<std::string>,
+      using ConcreteOperation<DeepLocateImpl, state, Arg<std::string>,
           Arg<OpenFlags::Flags>>::operator>>;
 
       DeepLocateImpl<Handled> operator>>(
@@ -263,7 +263,7 @@ namespace XrdCl
           typedef std::string type;
       };
 
-      using OperationBase<MvImpl, state, Arg<std::string>, Arg<std::string>>::operator>>;
+      using ConcreteOperation<MvImpl, state, Arg<std::string>, Arg<std::string>>::operator>>;
 
       MvImpl<Handled> operator>>(
           std::function<void( XRootDStatus& )> handleFunction )
@@ -342,7 +342,7 @@ namespace XrdCl
           typedef Buffer type;
       };
 
-      using OperationBase<QueryImpl, state, Arg<QueryCode::Code>, Arg<Buffer>>::operator>>;
+      using ConcreteOperation<QueryImpl, state, Arg<QueryCode::Code>, Arg<Buffer>>::operator>>;
 
       QueryImpl<Handled> operator>>(
           std::function<void( XRootDStatus&, Buffer& )> handleFunction )
@@ -423,7 +423,7 @@ namespace XrdCl
           typedef uint64_t type;
       };
 
-      using OperationBase<TruncateFsImpl, state, Arg<std::string>, Arg<uint64_t>>::operator>>;
+      using ConcreteOperation<TruncateFsImpl, state, Arg<std::string>, Arg<uint64_t>>::operator>>;
 
       TruncateFsImpl<Handled> operator>>(
           std::function<void( XRootDStatus& )> handleFunction )
@@ -497,7 +497,7 @@ namespace XrdCl
           typedef std::string type;
       };
 
-      using OperationBase<RmImpl, state, Arg<std::string>>::operator>>;
+      using ConcreteOperation<RmImpl, state, Arg<std::string>>::operator>>;
 
       RmImpl<Handled> operator>>(
           std::function<void( XRootDStatus& )> handleFunction )
@@ -580,7 +580,7 @@ namespace XrdCl
           typedef Access::Mode type;
       };
 
-      using OperationBase<MkDirImpl, state, Arg<std::string>,
+      using ConcreteOperation<MkDirImpl, state, Arg<std::string>,
           Arg<MkDirFlags::Flags>, Arg<Access::Mode>>::operator>>;
 
       MkDirImpl<Handled> operator>>(
@@ -656,7 +656,7 @@ namespace XrdCl
           typedef std::string type;
       };
 
-      using OperationBase<RmDirImpl, state, Arg<std::string>>::operator>>;
+      using ConcreteOperation<RmDirImpl, state, Arg<std::string>>::operator>>;
 
       RmDirImpl<Handled> operator>>(
           std::function<void( XRootDStatus& )> handleFunction )
@@ -733,7 +733,7 @@ namespace XrdCl
           typedef Access::Mode type;
       };
 
-      using OperationBase<ChModImpl, state, Arg<std::string>, Arg<Access::Mode>>::operator>>;
+      using ConcreteOperation<ChModImpl, state, Arg<std::string>, Arg<Access::Mode>>::operator>>;
 
       ChModImpl<Handled> operator>>(
           std::function<void( XRootDStatus& )> handleFunction )
@@ -795,7 +795,7 @@ namespace XrdCl
       {
       }
 
-      using OperationBase<PingImpl, state>::operator>>;
+      using ConcreteOperation<PingImpl, state>::operator>>;
 
       PingImpl<Handled> operator>>(
           std::function<void( XRootDStatus& )> handleFunction )
@@ -860,7 +860,7 @@ namespace XrdCl
           typedef std::string type;
       };
 
-      using OperationBase<StatFsImpl, state, Arg<std::string>>::operator>>;
+      using ConcreteOperation<StatFsImpl, state, Arg<std::string>>::operator>>;
 
       StatFsImpl<Handled> operator>>(
           std::function<void( XRootDStatus&, StatInfo& )> handleFunction )
@@ -932,7 +932,7 @@ namespace XrdCl
           typedef std::string type;
       };
 
-      using OperationBase<StatVFSImpl, state, Arg<std::string>>::operator>>;
+      using ConcreteOperation<StatVFSImpl, state, Arg<std::string>>::operator>>;
 
       StatVFSImpl<Handled> operator>>(
           std::function<void( XRootDStatus&, StatInfoVFS& )> handleFunction )
@@ -991,7 +991,7 @@ namespace XrdCl
       {
       }
 
-      using OperationBase<ProtocolImpl, state>::operator>>;
+      using ConcreteOperation<ProtocolImpl, state>::operator>>;
 
       ProtocolImpl<Handled> operator>>(
           std::function<void( XRootDStatus&, ProtocolInfo& )> handleFunction )
@@ -1065,7 +1065,7 @@ namespace XrdCl
           typedef DirListFlags::Flags type;
       };
 
-      using OperationBase<DirListImpl, state, Arg<std::string>,
+      using ConcreteOperation<DirListImpl, state, Arg<std::string>,
           Arg<DirListFlags::Flags>>::operator>>;
 
       DirListImpl<Handled> operator>>(
@@ -1138,7 +1138,7 @@ namespace XrdCl
           typedef std::string type;
       };
 
-      using OperationBase<SendInfoImpl, state, Arg<std::string>>::operator>>;
+      using ConcreteOperation<SendInfoImpl, state, Arg<std::string>>::operator>>;
 
       SendInfoImpl<Handled> operator>>(
           std::function<void( XRootDStatus&, Buffer& )> handleFunction )
@@ -1222,7 +1222,7 @@ namespace XrdCl
           typedef uint8_t type;
       };
 
-      using OperationBase<PrepareImpl, state, Arg<std::vector<std::string>>,
+      using ConcreteOperation<PrepareImpl, state, Arg<std::vector<std::string>>,
           Arg<PrepareFlags::Flags>, Arg<uint8_t>>::operator>>;
 
       PrepareImpl<Handled> operator>>(
diff --git a/src/XrdCl/XrdClOperations.cc b/src/XrdCl/XrdClOperations.cc
index 9b48379ea68..4af4825e0b6 100644
--- a/src/XrdCl/XrdClOperations.cc
+++ b/src/XrdCl/XrdClOperations.cc
@@ -156,6 +156,14 @@ namespace XrdCl
     firstOperation->AssignToWorkflow( this );
   }
 
+  Workflow::Workflow( Pipeline &&pipeline, bool enableLogging ) :
+      status( NULL ), logging( enableLogging )
+  {
+    if( !pipeline.operation )
+      throw std::invalid_argument( "Pipeline already has been executed." );
+    firstOperation = pipeline.operation.release();
+  }
+
   Workflow::~Workflow()
   {
     delete firstOperation;
diff --git a/src/XrdCl/XrdClOperations.hh b/src/XrdCl/XrdClOperations.hh
index b6e82d9b901..2f491a45f9f 100644
--- a/src/XrdCl/XrdClOperations.hh
+++ b/src/XrdCl/XrdClOperations.hh
@@ -41,8 +41,11 @@ namespace XrdCl
   {
     Bare, Configured, Handled
   };
+
   template<State state> class Operation;
 
+  class Pipeline;
+
   //---------------------------------------------------------------------------
   //! Handler allowing forwarding parameters to the next operation in workflow
   //---------------------------------------------------------------------------
@@ -175,6 +178,13 @@ namespace XrdCl
       //------------------------------------------------------------------------
       explicit Workflow( Operation<Configured>* op, bool enableLogging = true );
 
+      //------------------------------------------------------------------------
+      //! Constructor
+      //!
+      //! @param a pipeline object
+      //------------------------------------------------------------------------
+      Workflow( Pipeline &&pipeline, bool enableLogging = true );
+
       ~Workflow();
 
       //------------------------------------------------------------------------
@@ -373,6 +383,67 @@ namespace XrdCl
       std::unique_ptr<OperationHandler> handler;
   };
 
+
+  //----------------------------------------------------------------------
+  //! A wrapper around operation pipeline
+  //----------------------------------------------------------------------
+  class Pipeline
+  {
+      friend class Workflow;
+
+    public:
+
+      Pipeline( Operation<Handled>  *op ) : operation( op->Move() )
+      {
+
+      }
+
+      Pipeline( Operation<Handled>  &op ) : operation( op.Move() )
+      {
+
+      }
+
+      Pipeline( Operation<Handled> &&op ) : operation( op.Move() )
+      {
+
+      }
+
+      Pipeline( Operation<Configured>  *op ) : operation( op->ToHandled() )
+      {
+
+      }
+
+      Pipeline( Operation<Configured>  &op ) : operation( op.ToHandled() )
+      {
+
+      }
+
+      Pipeline( Operation<Configured> &&op ) : operation( op.ToHandled() )
+      {
+
+      }
+
+      Pipeline( Pipeline &&pipe ) : operation( std::move( pipe.operation ) )
+      {
+
+      }
+
+      Pipeline& operator=( Pipeline &&pipe )
+      {
+        operation = std::move( pipe.operation );
+        return *this;
+      }
+
+      operator Operation<Handled>&()
+      {
+        return *operation.get();
+      }
+
+    private:
+
+      std::unique_ptr<Operation<Handled>> operation;
+  };
+
   //----------------------------------------------------------------------
   //! ArgsOperation template
   //!
@@ -381,17 +452,17 @@ namespace XrdCl
   //! @param Args     operation arguments
   //----------------------------------------------------------------------
   template<template<State> class Derived, State state, typename ... Args>
-  class OperationBase: public Operation<state>
+  class ConcreteOperation: public Operation<state>
   {
-      template<template<State> class, State, typename ...> friend class OperationBase;
+      template<template<State> class, State, typename ...> friend class ConcreteOperation;
 
       public:
 
-      OperationBase()
+      ConcreteOperation()
       {}
 
       template<State from>
-      OperationBase( OperationBase<Derived, from, Args...> && op ) : Operation<state>( std::move( op ) ), args( std::move( op.args ) )
+      ConcreteOperation( ConcreteOperation<Derived, from, Args...> && op ) : Operation<state>( std::move( op ) ), args( std::move( op.args ) )
       {
 
       }
@@ -500,21 +571,21 @@ namespace XrdCl
       }
 
       inline static
-      Derived<Handled> PipeImpl( OperationBase<Derived, Handled, Args...> &me, Operation<Handled> &op )
+      Derived<Handled> PipeImpl( ConcreteOperation<Derived, Handled, Args...> &me, Operation<Handled> &op )
       {
         me.AddOperation( op.Move() );
         return me.Transform<Handled>();
       }
 
       inline static
-      Derived<Handled> PipeImpl( OperationBase<Derived, Handled, Args...> &me, Operation<Configured> &op )
+      Derived<Handled> PipeImpl( ConcreteOperation<Derived, Handled, Args...> &me, Operation<Configured> &op )
       {
         me.AddOperation( op.ToHandled() );
         return me.Transform<Handled>();
       }
 
       inline static
-      Derived<Handled> PipeImpl( OperationBase<Derived, Configured, Args...> &me, Operation<Handled> &op )
+      Derived<Handled> PipeImpl( ConcreteOperation<Derived, Configured, Args...> &me, Operation<Handled> &op )
       {
         me.handler.reset( new OperationHandler( new ForwardingHandler(), true ) );
         me.AddOperation( op.Move() );
@@ -522,7 +593,7 @@ namespace XrdCl
       }
 
       inline static
-      Derived<Handled> PipeImpl( OperationBase<Derived, Configured, Args...> &me, Operation<Configured> &op )
+      Derived<Handled> PipeImpl( ConcreteOperation<Derived, Configured, Args...> &me, Operation<Configured> &op )
       {
         me.handler.reset( new OperationHandler( new ForwardingHandler(), true ) );
         me.AddOperation( op.ToHandled() );
@@ -553,7 +624,7 @@ namespace XrdCl
   //! @tparam state   describes current operation configuration state
   //-----------------------------------------------------------------------
   template<State state = Bare>
-  class ParallelOperation: public OperationBase<ParallelOperation, state>
+  class ParallelOperation: public ConcreteOperation<ParallelOperation, state>
   {
       template<State> friend class ParallelOperation;
 
@@ -578,22 +649,20 @@ namespace XrdCl
 
       template<State from>
       ParallelOperation( ParallelOperation<from> &&obj ) :
-          OperationBase<ParallelOperation, state>( std::move( obj ) ), workflows(
+          ConcreteOperation<ParallelOperation, state>( std::move( obj ) ), workflows(
               std::move( obj.workflows ) )
       {
       }
 
-      template<typename Container>
+      template<class Container>
       ParallelOperation( Container &container )
       {
         static_assert(state == Configured, "Constructor is available only for type ParallelOperations<Configured>");
-        static_assert(std::is_same<typename Container::value_type, Operation<Handled>*>::value, "Invalid type in container");
-        typename Container::iterator it = container.begin();
-        while( it != container.end() )
+        auto itr = container.begin();
+        for( ; itr != container.end(); ++itr )
         {
-          std::unique_ptr<Workflow> w( new Workflow( *it, false ) );
+          std::unique_ptr<Workflow> w( new Workflow( *itr, false ) );
           workflows.push_back( std::move( w ) );
-          ++it;
         }
       }