Index: src/Fragmentation/Automation/FragmentScheduler.cpp
===================================================================
--- src/Fragmentation/Automation/FragmentScheduler.cpp	(revision 630a6e76e8fd0da3d37d517432a74ebda2a494f2)
+++ src/Fragmentation/Automation/FragmentScheduler.cpp	(revision ef27671d6947ddc9fc6ee4fd2fbb213a4ab7174a)
@@ -35,4 +35,5 @@
 #include "CodePatterns/Log.hpp"
 #include "FragmentJob.hpp"
+#include "JobId.hpp"
 
 #include "FragmentScheduler.hpp"
@@ -43,5 +44,6 @@
   acceptor_(io_service,
       boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)
-  )
+  ),
+  result(JobId::NoJob)
 {
   Info info(__FUNCTION__);
@@ -60,5 +62,4 @@
 {
   Info info(__FUNCTION__);
-  std::cout << "handle_accept called." << std::endl;
   if (!e)
   {
@@ -67,8 +68,9 @@
     if (JobsQueue.isJobPresent()) {
       // pop a job and send it to the client.
-      FragmentJob s(JobsQueue.popJob());
+      FragmentJob job(JobsQueue.popJob());
       // The connection::async_write() function will automatically
       // serialize the data structure for us.
-      conn->async_write(s,
+      LOG(1, "INFO: Sending job #" << job.getId() << ".");
+      conn->async_write(job,
         boost::bind(&FragmentScheduler::handle_write, this,
         boost::asio::placeholders::error, conn));
@@ -85,4 +87,6 @@
         boost::bind(&FragmentScheduler::handle_write, this,
         boost::asio::placeholders::error, conn));
+
+      // then there must be no read necesary
 
       ELOG(2, "There is currently no job present in the queue.");
@@ -102,6 +106,27 @@
 {
     Info info(__FUNCTION__);
-  // Nothing to do. The socket will be closed automatically when the last
-  // reference to the connection object goes away.
+    LOG(1, "INFO: Job sent.");
+    // obtain result
+    LOG(1, "INFO: Receiving result for a job ...");
+    conn->async_read(result,
+      boost::bind(&FragmentScheduler::handle_read, this,
+      boost::asio::placeholders::error, conn));
 }
 
+/// Handle completion of a read operation.
+void FragmentScheduler::handle_read(const boost::system::error_code& e, connection_ptr conn)
+{
+    Info info(__FUNCTION__);
+    // nothing to do
+    LOG(1, "INFO: Received result for job #" << result.getId() << " ...");
+    // and push into queue
+    ASSERT(result.getId() != JobId::NoJob,
+        "FragmentScheduler::handle_write() - result received has NoJob id.");
+    ASSERT(result.getId() != JobId::IllegalJob,
+        "FragmentScheduler::handle_write() - result received has IllegalJob id.");
+    if ((result.getId() != JobId::NoJob) && (result.getId() != JobId::IllegalJob))
+      JobsQueue.pushResult(result);
+    // erase result
+    result = FragmentResult(JobId::NoJob);
+}
+
Index: src/Fragmentation/Automation/FragmentScheduler.hpp
===================================================================
--- src/Fragmentation/Automation/FragmentScheduler.hpp	(revision 630a6e76e8fd0da3d37d517432a74ebda2a494f2)
+++ src/Fragmentation/Automation/FragmentScheduler.hpp	(revision ef27671d6947ddc9fc6ee4fd2fbb213a4ab7174a)
@@ -20,4 +20,5 @@
 #include "FragmentJob.hpp"
 #include "FragmentQueue.hpp"
+#include "FragmentResult.hpp"
 
 /** FragmentScheduler serves FragmentJobs to Workers.
@@ -37,7 +38,13 @@
   void handle_write(const boost::system::error_code& e, connection_ptr conn);
 
+  /// Handle completion of a read operation.
+  void handle_read(const boost::system::error_code& e, connection_ptr conn);
+
 private:
   /// The acceptor object used to accept incoming socket connections.
   boost::asio::ip::tcp::acceptor acceptor_;
+
+  /// result that is received from the client.
+  FragmentResult result;
 
   /// Queue with data to be sent to each client.
Index: src/Fragmentation/Automation/FragmentWorker.cpp
===================================================================
--- src/Fragmentation/Automation/FragmentWorker.cpp	(revision 630a6e76e8fd0da3d37d517432a74ebda2a494f2)
+++ src/Fragmentation/Automation/FragmentWorker.cpp	(revision ef27671d6947ddc9fc6ee4fd2fbb213a4ab7174a)
@@ -34,5 +34,8 @@
 #include "CodePatterns/Log.hpp"
 #include "FragmentJob.hpp"
+#include "FragmentResult.hpp"
 #include "FragmentWorker.hpp"
+
+FragmentResult FragmentWorker::EmptyResult(JobId::NoJob, std::string("EmptyResult"));
 
 /// Constructor starts the asynchronous connect operation.
@@ -64,5 +67,5 @@
     boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
 {
-    Info info(__FUNCTION__);
+  Info info(__FUNCTION__);
   if (!e)
   {
@@ -70,4 +73,5 @@
     // of jobs. The connection::async_read() function will automatically
     // decode the data that is read from the underlying socket.
+    LOG(1, "INFO: Receiving a job ...");
     connection_.async_read(job,
       boost::bind(&FragmentWorker::handle_read, this,
@@ -95,12 +99,27 @@
   if (!e)
   {
+    LOG(1, "INFO: Received job #" << job.getId() << ".");
     if (job.getId() != JobId::NoJob) {
       // Print out the data that was received.
       std::cout << "Job output: " << job.outputfile << "\n";
       std::cout << "Job id: " << job.getId() << "\n";
+
       // do something .. right now: wait
-      result = job.Work();
+      LOG(1, "INFO: Calculating job #" << job.getId() << " ...");
+      FragmentResult result(job.Work());
+
+      // write the result to the server
+      LOG(1, "INFO: Sending result for job #" << job.getId() << " ...");
+      connection_.async_write(result,
+        boost::bind(&FragmentWorker::handle_write, this,
+        boost::asio::placeholders::error));
+
     } else {
       std::cout << "The server has no job for me." << std::endl;
+      // send out empty result
+      LOG(1, "INFO: Sending empty result ...");
+      connection_.async_write(EmptyResult,
+        boost::bind(&FragmentWorker::handle_write, this,
+        boost::asio::placeholders::error));
       Exitflag = NoJobFlag;
     }
@@ -117,2 +136,12 @@
 }
 
+/// Handle completion of a write operation.
+void FragmentWorker::handle_write(const boost::system::error_code& e)
+{
+  Info info(__FUNCTION__);
+  // Nothing to do.
+  LOG(1, "INFO: Job #" << job.getId() << " calculated and sent.");
+  // erase job
+  job = FragmentJob();
+}
+
Index: src/Fragmentation/Automation/FragmentWorker.hpp
===================================================================
--- src/Fragmentation/Automation/FragmentWorker.hpp	(revision 630a6e76e8fd0da3d37d517432a74ebda2a494f2)
+++ src/Fragmentation/Automation/FragmentWorker.hpp	(revision ef27671d6947ddc9fc6ee4fd2fbb213a4ab7174a)
@@ -18,5 +18,4 @@
 #include "Connection.hpp"
 #include "FragmentJob.hpp"
-#include "FragmentResult.hpp"
 
 /** Receives a job from Server to execute and return FragmentResult.
@@ -37,4 +36,7 @@
   void handle_read(const boost::system::error_code& e);
 
+  /// Handle completion of a write operation.
+  void handle_write(const boost::system::error_code& e);
+
   enum Exitflag_t {
     OkFlag = 0,
@@ -52,4 +54,7 @@
 
 private:
+  // static entity of an empty result
+  static FragmentResult EmptyResult;
+
   /// The Connection to the server.
   Connection connection_;
