diff --git a/include/pfasst/controller/pfasst.hpp b/include/pfasst/controller/pfasst.hpp
index c0600226..06cd18fe 100644
--- a/include/pfasst/controller/pfasst.hpp
+++ b/include/pfasst/controller/pfasst.hpp
@@ -80,6 +80,7 @@ namespace pfasst
        * @param[in] level_iter level iterator providing information to compute the communication tag
        */
       virtual int tag(LevelIter level_iter);
+      virtual int stag(LevelIter level_iter);
 
       /**
        * Post current status and values to next processor.
diff --git a/include/pfasst/encap/vector.hpp b/include/pfasst/encap/vector.hpp
index fbaabf3e..75ddfd1f 100644
--- a/include/pfasst/encap/vector.hpp
+++ b/include/pfasst/encap/vector.hpp
@@ -61,7 +61,7 @@ namespace pfasst
          */
         VectorEncapsulation(Encapsulation<time>&& other);
 
-        virtual ~VectorEncapsulation() = default;
+        virtual ~VectorEncapsulation();
         //! @}
 
         //! @{
diff --git a/include/pfasst/interfaces.hpp b/include/pfasst/interfaces.hpp
index db56e1dc..6e607748 100644
--- a/include/pfasst/interfaces.hpp
+++ b/include/pfasst/interfaces.hpp
@@ -86,6 +86,10 @@ namespace pfasst
    */
   class IStatus
   {
+    public:
+      static const int NOT_CONVERGED = 0;
+      static const int CONVERGED = 1;
+
     protected:
       ICommunicator* comm;
 
@@ -139,9 +143,9 @@ namespace pfasst
       //! @}
 
       //! @{
-      virtual void post() = 0;
-      virtual void send() = 0;
-      virtual void recv() = 0;
+      virtual void post(int tag) = 0;
+      virtual void send(int tag) = 0;
+      virtual void recv(int tag) = 0;
       //! @}
   };
 
@@ -218,7 +222,7 @@ namespace pfasst
        * Perform one SDC sweep/iteration.
        *
        * Compute a correction and update solution values.
-       * Note that this function can assume that valid function values exist from a previous 
+       * Note that this function can assume that valid function values exist from a previous
        * pfasst::ISweeper::sweep() or pfasst::ISweeper::predict().
        */
       virtual void sweep() = 0;
@@ -310,7 +314,7 @@ namespace pfasst
        *
        * @param[in,out] dst            sweeper to interpolate onto (i.e. fine level)
        * @param[in]     src            sweeper to interpolate from (i.e. coarse level)
-       * @param[in]     interp_initial `true` if a delta for the initial condtion should also be 
+       * @param[in]     interp_initial `true` if a delta for the initial condtion should also be
        *   computed (PFASST)
        */
       virtual void interpolate(shared_ptr<ISweeper<time>> dst,
diff --git a/include/pfasst/mpi_communicator.hpp b/include/pfasst/mpi_communicator.hpp
index e0cd33d9..1e22ff82 100644
--- a/include/pfasst/mpi_communicator.hpp
+++ b/include/pfasst/mpi_communicator.hpp
@@ -11,6 +11,29 @@ using namespace std;
 #include "pfasst/logging.hpp"
 
 
+/**
+ * creates and initializes a new _empty_ `MPI_Status` object
+ *
+ * An _empty_ `MPI_Status` is defined as an `MPI_Status` object with `MPI_ERROR` as `MPI_SUCCESS`,
+ * `MPI_SOURCE` as `MPI_ANY_SOURCE` and `MPI_TAG` as `MPI_ANY_TAG`
+ * (cf. MPI Standard v3; section 3.7.3).
+ *
+ * rationale: some MPI implementations don't initialize the members of `MPI_Status` correctly
+ *
+ * @returns _empty_ `MPI_Status` object
+ *
+ * @ingroup Utilities
+ */
+inline static MPI_Status MPI_Status_factory()
+{
+  MPI_Status stat;
+  stat.MPI_ERROR = MPI_SUCCESS;
+  stat.MPI_SOURCE = MPI_ANY_SOURCE;
+  stat.MPI_TAG = MPI_ANY_TAG;
+  return stat;
+}
+
+
 namespace pfasst
 {
   namespace mpi
@@ -19,10 +42,24 @@ namespace pfasst
       : public runtime_error
     {
       public:
-        explicit MPIError(const string& msg="");
+        MPIError(const string& msg="");
         virtual const char* what() const throw();
+        static MPIError from_code(const int err_code);
     };
 
+    /**
+     * checks MPI error code
+     *
+     * In case @p err_code is not `MPI_SUCCESS` this throws MPIError with the error code looked up
+     * to a descriptive string as defined by the MPI implementation.
+     */
+    inline static void check_mpi_error(const int err_code)
+    {
+      if (err_code != MPI_SUCCESS) {
+        throw MPIError::from_code(err_code);
+      }
+    }
+
 
     // forward declare for MPICommunicator
     class MPIStatus;
@@ -68,9 +105,9 @@ namespace pfasst
         virtual void clear() override;
         virtual void set_converged(bool converged) override;
         virtual bool get_converged(int rank) override;
-        virtual void post();
-        virtual void send();
-        virtual void recv();
+        virtual void post(int tag) override;
+        virtual void send(int tag) override;
+        virtual void recv(int tag) override;
     };
   }  // ::pfasst::mpi
 }  // ::pfasst
diff --git a/src/pfasst/controller/pfasst_impl.hpp b/src/pfasst/controller/pfasst_impl.hpp
index 3bb851ef..63f6e660 100644
--- a/src/pfasst/controller/pfasst_impl.hpp
+++ b/src/pfasst/controller/pfasst_impl.hpp
@@ -101,9 +101,7 @@ namespace pfasst
     }
 
     fine->send(comm, tag(l), false);
-
     trns->restrict(crse, fine, true);
-
     trns->fas(this->get_time_step(), crse, fine);
     crse->save();
 
@@ -118,11 +116,8 @@ namespace pfasst
     auto trns = level_iter.transfer();
 
     trns->interpolate(fine, crse, true);
-
-    if (this->comm->status->previous_is_iterating()) {
-      fine->recv(comm, tag(level_iter), false);
-      trns->interpolate_initial(fine, crse);
-    }
+    fine->recv(comm, tag(level_iter), false);
+    trns->interpolate_initial(fine, crse);
 
     if (level_iter < this->finest()) {
       perform_sweeps(level_iter.level);
@@ -139,10 +134,11 @@ namespace pfasst
     if (this->comm->status->previous_is_iterating()) {
       crse->recv(comm, tag(level_iter), true);
     }
-    this->comm->status->recv();
+    this->comm->status->recv(stag(level_iter));
     this->perform_sweeps(level_iter.level);
     crse->send(comm, tag(level_iter), true);
-    this->comm->status->send();
+    this->comm->status->set_converged(!this->comm->status->keep_iterating());
+    this->comm->status->send(stag(level_iter));
     return level_iter + 1;
   }
 
@@ -208,13 +204,19 @@ namespace pfasst
    * @internals
    * A simple formula is used with current level index \\( L \\) (provided by @p level_iter) and
    * current iteration number \\( I \\):
-   * \\[ L * 10000 + I + 10 \\]
+   * \\[ (L+1) * 10000 + I \\]
    * @endinternals
    */
   template<typename time>
   int PFASST<time>::tag(LevelIter level_iter)
   {
-    return level_iter.level * 10000 + this->get_iteration() + 10;
+    return (level_iter.level+1) * 10000 + this->get_iteration();
+  }
+
+  template<typename time>
+  int PFASST<time>::stag(LevelIter level_iter)
+  {
+    return level_iter.level * 1000 + this->get_iteration();
   }
 
   /**
@@ -224,9 +226,11 @@ namespace pfasst
   template<typename time>
   void PFASST<time>::post()
   {
-    this->comm->status->post();
-    for (auto l = this->coarsest() + 1; l <= this->finest(); ++l) {
-      l.current()->post(comm, tag(l));
+    if (this->comm->status->previous_is_iterating()) {
+      this->comm->status->post(0);
+      for (auto l = this->coarsest() + 1; l <= this->finest(); ++l) {
+        l.current()->post(comm, tag(l));
+      }
     }
   }
 }  // ::pfasst
diff --git a/src/pfasst/encap/vector_impl.hpp b/src/pfasst/encap/vector_impl.hpp
index 270339df..9435c7cf 100644
--- a/src/pfasst/encap/vector_impl.hpp
+++ b/src/pfasst/encap/vector_impl.hpp
@@ -34,6 +34,22 @@ namespace pfasst
       : VectorEncapsulation(dynamic_cast<VectorEncapsulation<scalar, time>&&>(other))
     {}
 
+    template<typename scalar, typename time>
+    VectorEncapsulation<scalar, time>::~VectorEncapsulation()
+    {
+#ifdef WITH_MPI
+      if (this->send_request != MPI_REQUEST_NULL) {
+        MPI_Status stat = MPI_Status_factory();
+        CLOG(DEBUG, "Encap") << "waiting for open send request";
+        int err = MPI_Wait(&(this->send_request), &stat);
+        check_mpi_error(err);
+        CLOG(DEBUG, "Encap") << "waited for open send request";
+      }
+      assert(this->recv_request == MPI_REQUEST_NULL);
+      assert(this->send_request == MPI_REQUEST_NULL);
+#endif
+    }
+
     template<typename scalar, typename time>
     void VectorEncapsulation<scalar, time>::zero()
     {
@@ -165,18 +181,23 @@ namespace pfasst
     }
 
 #ifdef WITH_MPI
-        template<typename scalar, typename time>
+    template<typename scalar, typename time>
     void VectorEncapsulation<scalar, time>::post(ICommunicator* comm, int tag)
     {
       auto& mpi = as_mpi(comm);
       if (mpi.size() == 1) { return; }
       if (mpi.rank() == 0) { return; }
 
-      int err = MPI_Irecv(this->data(), sizeof(scalar) * this->size(), MPI_CHAR,
-                          (mpi.rank() - 1) % mpi.size(), tag, mpi.comm, &recv_request);
-      if (err != MPI_SUCCESS) {
-        throw MPIError();
+      if (this->recv_request != MPI_REQUEST_NULL) {
+        throw MPIError("a previous receive request is still open");
       }
+
+      int src = (mpi.rank() - 1) % mpi.size();
+      CLOG(DEBUG, "Encap") << "non-blocking receiving from rank " << src << " with tag=" << tag;
+      int err = MPI_Irecv(this->data(), sizeof(scalar) * this->size(), MPI_CHAR,
+                          src, tag, mpi.comm, &this->recv_request);
+      check_mpi_error(err);
+      CLOG(DEBUG, "Encap") << "non-blocking received from rank " << src << " with tag=" << tag;
     }
 
     template<typename scalar, typename time>
@@ -186,18 +207,23 @@ namespace pfasst
       if (mpi.size() == 1) { return; }
       if (mpi.rank() == 0) { return; }
 
-      int err;
+      MPI_Status stat = MPI_Status_factory();
+      int err = MPI_SUCCESS;
+
       if (blocking) {
-        MPI_Status stat;
+        int src = (mpi.rank() - 1) % mpi.size();
+        CLOG(DEBUG, "Encap") << "blocking receive from rank " << src << " with tag=" << tag;
         err = MPI_Recv(this->data(), sizeof(scalar) * this->size(), MPI_CHAR,
-                       (mpi.rank() - 1) % mpi.size(), tag, mpi.comm, &stat);
+                       src, tag, mpi.comm, &stat);
+        check_mpi_error(err);
+        CLOG(DEBUG, "Encap") << "received blocking from rank " << src << " with tag=" << tag << ": " << stat;
       } else {
-        MPI_Status stat;
-        err = MPI_Wait(&recv_request, &stat);
-      }
-
-      if (err != MPI_SUCCESS) {
-        throw MPIError();
+        if (this->recv_request != MPI_REQUEST_NULL) {
+          CLOG(DEBUG, "Encap") << "waiting on last receive request";
+          err = MPI_Wait(&(this->recv_request), &stat);
+          check_mpi_error(err);
+          CLOG(DEBUG, "Encap") << "waited on last receive request: " << stat;
+        }
       }
     }
 
@@ -208,23 +234,26 @@ namespace pfasst
       if (mpi.size() == 1) { return; }
       if (mpi.rank() == mpi.size() - 1) { return; }
 
+      MPI_Status stat = MPI_Status_factory();
       int err = MPI_SUCCESS;
+      int dest = (mpi.rank() + 1) % mpi.size();
+
       if (blocking) {
-        err = MPI_Send(this->data(), sizeof(scalar) * this->size(), MPI_CHAR,
-                       (mpi.rank() + 1) % mpi.size(), tag, mpi.comm);
+        CLOG(DEBUG, "Encap") << "blocking send to rank " << dest << " with tag=" << tag;
+        err = MPI_Send(this->data(), sizeof(scalar) * this->size(), MPI_CHAR, dest, tag, mpi.comm);
+        check_mpi_error(err);
+        CLOG(DEBUG, "Encap") << "sent blocking to rank " << dest << " with tag=" << tag;
       } else {
-        MPI_Status stat;
-        err = MPI_Wait(&send_request, &stat);
-        if (err != MPI_SUCCESS) {
-          throw MPIError();
-        }
-
+        // got never in here
+        CLOG(DEBUG, "Encap") << "waiting on last send request to finish";
+        err = MPI_Wait(&(this->send_request), &stat);
+        check_mpi_error(err);
+        CLOG(DEBUG, "Encap") << "waited on last send request: " << stat;
+        CLOG(DEBUG, "Encap") << "non-blocking sending to rank " << dest << " with tag=" << tag;
         err = MPI_Isend(this->data(), sizeof(scalar) * this->size(), MPI_CHAR,
-                        (mpi.rank() + 1) % mpi.size(), tag, mpi.comm, &send_request);
-      }
-
-      if (err != MPI_SUCCESS) {
-        throw MPIError();
+                        dest, tag, mpi.comm, &(this->send_request));
+        check_mpi_error(err);
+        CLOG(DEBUG, "Encap") << "sent non-blocking to rank " << dest << " with tag=" << tag;
       }
     }
 
@@ -232,12 +261,11 @@ namespace pfasst
     void VectorEncapsulation<scalar, time>::broadcast(ICommunicator* comm)
     {
       auto& mpi = as_mpi(comm);
+      CLOG(DEBUG, "Encap") << "broadcasting";
       int err = MPI_Bcast(this->data(), sizeof(scalar) * this->size(), MPI_CHAR,
                           comm->size()-1, mpi.comm);
-
-      if (err != MPI_SUCCESS) {
-        throw MPIError();
-      }
+      check_mpi_error(err);
+      CLOG(DEBUG, "Encap") << "broadcasted";
     }
 #endif
 
diff --git a/src/pfasst/interfaces_impl.hpp b/src/pfasst/interfaces_impl.hpp
index 57b261a4..79a79c2e 100644
--- a/src/pfasst/interfaces_impl.hpp
+++ b/src/pfasst/interfaces_impl.hpp
@@ -6,6 +6,7 @@
 using namespace std;
 
 #include "pfasst/globals.hpp"
+#include "pfasst/logging.hpp"
 
 
 namespace pfasst
@@ -78,7 +79,11 @@ namespace pfasst
     if (this->comm->rank() == 0) {
       return !this->get_converged(0);
     }
-    return !this->get_converged(this->comm->rank()) || !this->get_converged(this->comm->rank() - 1);
+    bool keep_iterating = !this->get_converged(this->comm->rank() - 1) || !this->get_converged(this->comm->rank());
+    CLOG(DEBUG, "Controller") << "previous converged: " << boolalpha << this->get_converged(this->comm->rank() - 1)
+                              << "; this converged: " << boolalpha << this->get_converged(this->comm->rank())
+                              << " --> keep iterating: " << boolalpha << keep_iterating;
+    return keep_iterating;
   }
 
 
diff --git a/src/pfasst/mpi_communicator_impl.hpp b/src/pfasst/mpi_communicator_impl.hpp
index 53268514..497adfc4 100644
--- a/src/pfasst/mpi_communicator_impl.hpp
+++ b/src/pfasst/mpi_communicator_impl.hpp
@@ -16,6 +16,15 @@ namespace pfasst
       return (string("mpi error: ") + string(runtime_error::what())).c_str();
     }
 
+    MPIError MPIError::from_code(const int err_code)
+    {
+      char err_str[MPI_MAX_ERROR_STRING];
+      int err_len = 0;
+      int err = MPI_Error_string(err_code, err_str, &err_len);
+      check_mpi_error(err);
+      return MPIError("MPI Error: " + string(err_str, err_len) + " (code=" + to_string(err_code) + ")");
+    }
+
 
     MPICommunicator::MPICommunicator()
     {}
@@ -32,7 +41,8 @@ namespace pfasst
       MPI_Comm_rank(this->comm, &(this->_rank));
       int len = 0;
       char buff[MPI_MAX_OBJECT_NAME];
-      MPI_Comm_get_name(this->comm, buff, &len);
+      int err = MPI_Comm_get_name(this->comm, buff, &len);
+      check_mpi_error(err);
       if (len == 0) {
         this->_name = string("world");
       } else {
@@ -75,8 +85,10 @@ namespace pfasst
 
     void MPIStatus::set_converged(bool converged)
     {
-      CLOG(DEBUG, "Controller") << "set converged to " << boolalpha << converged;
+      CLOG(DEBUG, "Controller") << "set converged for rank " << this->comm->rank() << " to "
+                                << "'" << boolalpha << converged << "'";
       this->converged.at(this->comm->rank()) = converged;
+      assert(this->converged.at(this->comm->rank()) == converged);
     }
 
     bool MPIStatus::get_converged(int rank)
@@ -84,56 +96,51 @@ namespace pfasst
       return this->converged.at(rank);
     }
 
-    void MPIStatus::post()
+    void MPIStatus::post(int tag)
     {
       // noop: send/recv for status info is blocking
+      UNUSED(tag);
     }
 
-    void MPIStatus::send()
+    void MPIStatus::send(int tag)
     {
       // don't send forward if: single processor run, or we're the last processor
       if (mpi->size() == 1) { return; }
       if (mpi->rank() == mpi->size() - 1) { return; }
 
-      int iconverged = converged.at(mpi->rank()) ? 1 : 0;
-
+      int iconverged = converged.at(mpi->rank()) ? IStatus::CONVERGED : IStatus::NOT_CONVERGED;
       int dest_rank = (mpi->rank() + 1) % mpi->size();
-      CLOG(DEBUG, "Controller") << "sending status " << iconverged
-                                << " to " << dest_rank << " of communicator " << mpi->name();
-
-      int err = MPI_Send(&iconverged, sizeof(int), MPI_INT,
-                         dest_rank, 1, mpi->comm);
 
-      if (err != MPI_SUCCESS) {
-        throw MPIError();
-      }
+      CLOG(DEBUG, "Controller") << "sending converged status to rank " << dest_rank
+                                << " with tag " << tag << ": "
+                                << boolalpha << ((bool)iconverged == IStatus::CONVERGED);
+      int err = MPI_Send(&iconverged, 1, MPI_INT, dest_rank, tag, mpi->comm);
+      check_mpi_error(err);
+      CLOG(DEBUG, "Controller") << "sent converged status";
     }
 
-    void MPIStatus::recv()
+    void MPIStatus::recv(int tag)
     {
       // don't recv if: single processor run, or we're the first processor
       if (mpi->size() == 1) { return; }
       if (mpi->rank() == 0) { return; }
 
-      if (get_converged(mpi->rank()-1)) {
-        CLOG(DEBUG, "Controller") << "skipping status recv";
+      if (get_converged(mpi->rank() - 1)) {
+        CLOG(DEBUG, "Controller") << "skipping status recieve as previous is stored as converged";
         return;
       }
 
-      MPI_Status stat;
-      int iconverged;
+      MPI_Status stat = MPI_Status_factory();
+      int iconverged = IStatus::NOT_CONVERGED;
       int src_rank = (mpi->rank() - 1) % mpi->size();
-      int err = MPI_Recv(&iconverged, sizeof(iconverged), MPI_INT,
-                         src_rank, 1, mpi->comm, &stat);
-
-      if (err != MPI_SUCCESS) {
-        throw MPIError();
-      }
-
-      converged.at(mpi->rank()-1) = iconverged == 1 ? true : false;
-
-      CLOG(DEBUG, "Controller") << "recieved status " << iconverged
-                                << " from rank " << src_rank << " of communicator " << mpi->name();
+      CLOG(DEBUG, "Controller") << "receiving converged status from rank " << src_rank << " with tag '1'";
+      int err = MPI_Recv(&iconverged, 1, MPI_INT, src_rank, tag, mpi->comm, &stat);
+      check_mpi_error(err);
+      CLOG(DEBUG, "Controller") << "received converged status from rank " << src_rank
+                                << " with tag "<< tag << ": "
+                                << boolalpha << ((bool)iconverged == IStatus::CONVERGED);
+
+      converged.at(mpi->rank() - 1) = (iconverged == IStatus::CONVERGED) ? true : false;
     }
   }  // ::pfasst::mpi
 }  // ::pfasst
@@ -141,8 +148,18 @@ namespace pfasst
 
 MAKE_LOGGABLE(MPI_Status, mpi_status, os)
 {
-  os << "MPI_Status(source=" << mpi_status.MPI_SOURCE << ", "
-                << "tag=" << mpi_status.MPI_TAG << ", "
-                << "error=" << mpi_status.MPI_ERROR << ")";
+  if (   mpi_status.MPI_TAG == MPI_ANY_TAG
+      && mpi_status.MPI_SOURCE == MPI_ANY_SOURCE
+      && mpi_status.MPI_ERROR == MPI_SUCCESS) {
+    os << "MPI_Status(empty)";
+  } else {
+    char err_str[MPI_MAX_ERROR_STRING];
+    int err_len = 0;
+    int err = MPI_Error_string(mpi_status.MPI_ERROR, err_str, &err_len);
+    pfasst::mpi::check_mpi_error(err);
+    os << "MPI_Status(source=" << to_string(mpi_status.MPI_SOURCE) << ", "
+                  << "tag=" << to_string(mpi_status.MPI_TAG) << ", "
+                  << "error=" << string(err_str, err_len) << ")";
+  }
   return os;
 }