diff --git a/examples/secure-tcp/client/.client.go.swp b/examples/secure-tcp/client/.client.go.swp
index 1fd0ba4..3fb46c7 100644
--- a/examples/secure-tcp/client/.client.go.swp
+++ b/examples/secure-tcp/client/.client.go.swp
Binary files differ
diff --git a/examples/secure-tcp/client/client.go b/examples/secure-tcp/client/client.go
index 4fb6f99..9ef9d98 100644
--- a/examples/secure-tcp/client/client.go
+++ b/examples/secure-tcp/client/client.go
@@ -29,4 +29,10 @@
 	fmt.Fprintf(conn, "Hello.")
 	status, err := bufio.NewReader(conn).ReadString('\n')
 	log.Printf("Client received: %s\n", status)
+
+	time.Sleep(5 * time.Second)
+
+	fmt.Fprintf(conn, "World.")
+	status, err = bufio.NewReader(conn).ReadString('\n')
+	log.Printf("Client received: %s\n", status)
 }
diff --git a/examples/secure-tcp/server/.server.go.swp b/examples/secure-tcp/server/.server.go.swp
index 12e89fb..bfec12f 100644
--- a/examples/secure-tcp/server/.server.go.swp
+++ b/examples/secure-tcp/server/.server.go.swp
Binary files differ
diff --git a/examples/secure-tcp/server/server.go b/examples/secure-tcp/server/server.go
index db23317..3989888 100644
--- a/examples/secure-tcp/server/server.go
+++ b/examples/secure-tcp/server/server.go
@@ -33,5 +33,9 @@
 		status, err := bufio.NewReader(conn).ReadString('.')
 		// log.Printf("Server received: %s\n", status)
 		fmt.Fprintf(conn, "I heard: '%s'\n", status)
+
+		status, err = bufio.NewReader(conn).ReadString('.')
+		// log.Printf("Server received: %s\n", status)
+		fmt.Fprintf(conn, "I heard: '%s'\n", status)
 	}
 }
diff --git a/runtime/internal/flow/conn/grpc/conn.go b/runtime/internal/flow/conn/grpc/conn.go
index 28834f8..67a1f6e 100644
--- a/runtime/internal/flow/conn/grpc/conn.go
+++ b/runtime/internal/flow/conn/grpc/conn.go
@@ -39,31 +39,41 @@
 	mu        sync.Mutex
 }
 
+// TODO: what if bytesRead < 3? = 3?
 func (c *conn) Read(b []byte) (n int, err error) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	log.Printf("Beginning to Read.\n")
-	resBuf := make([]byte, 4096*4096) // TODO better (dynamic) size or way of reading?
 
+	frame := [3]byte{}
+	frameCopied, err := c.rawConn.Read(frame[:])
+	if frameCopied != 3 {
+		return -1, errors.New("Did not copy 3 frame bytes.")
+	}
+	msgSize := read3ByteUint(frame)
+
+	resBuf := make([]byte, msgSize) // TODO better (dynamic) size or way of reading?
 	bytesRead, err := c.rawConn.Read(resBuf)
-	log.Printf("Read %d bytes: %v\n", bytesRead, resBuf[:bytesRead])
+	// log.Printf("Read %d bytes: %v\n", bytesRead, resBuf)
 	if err != nil {
-		log.Printf("Failed to read.\n")
+		// log.Printf("Failed to read.\n")
 		log.Fatal(err)
 		return bytesRead, err
 	}
 
 	// tmp := make([]byte, 0, bytesRead-box.Overhead) // TODO: is this enough? Also, why do we need both of tmp and out?
-	out, ok := box.OpenAfterPrecomputation(nil, resBuf[:bytesRead], c.currentNonce(), c.sharedKey)
+	out, ok := box.OpenAfterPrecomputation(nil, resBuf, c.currentNonce(), c.sharedKey)
+	log.Printf("%d bytes after opening: %v\n", len(out), out)
+	log.Printf("%d bytes after opening: %v\n", len(out), string(out))
 	c.advanceNonce() // TODO: defer? Is there harm in advancing often than necessary (i.e. on error)?
 	if !ok {
-		log.Printf("Failed to decrypt.\n")
+		// log.Printf("Failed to decrypt.\n")
 		//log.Fatal(err)
 		return 0, err
 	}
 	copy(b, out)
 	// should we return bytesRead or len(b)?
-	log.Printf("cap(b): %d, len(b) %d, \ncap(out): %d, len(out): %d\n", cap(b), len(b), cap(out), len(out))
+	// log.Printf("cap(b): %d, len(b) %d, \ncap(out): %d, len(out): %d\n", cap(b), len(b), cap(out), len(out))
 	log.Printf("Succeeded in reading.\n\n")
 	// return bytesRead, nil
 	return len(b), nil
@@ -75,20 +85,18 @@
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	log.Printf("Beginning to write.\n")
+	log.Printf("%d bytes before sealing: %v\n", len(b), b)
 	tmp := make([]byte, 3, 3+len(b)+box.Overhead) // TODO: is this enough? Also, why do we need both of tmp and out?
-	tmp[0] = 5
-	tmp[1] = 7
-	tmp[2] = 14
+	err = write3ByteUint(tmp[:3], len(b)+box.Overhead)
+	if err != nil {
+		return -1, err
+	}
 	out := box.SealAfterPrecomputation(tmp, b, c.currentNonce(), c.sharedKey)
-	log.Printf("tmp: %v", tmp)
-	log.Printf("out: %v", out)
-	log.Printf("tmp[0]: %p", &tmp[0])
-	log.Printf("tmp[1]: %p", &tmp[1])
-	log.Printf("tmp[2]: %p", &tmp[2])
-	log.Printf("out[0]: %p", &out[0])
+	// log.Printf("tmp: %v", tmp)
+	// log.Printf("out: %v", out)
 	c.advanceNonce()
 	bytesCopied, err := io.Copy(c.rawConn, bytes.NewReader(out))
-	log.Printf("Wrote %d bytes.\n", bytesCopied)
+	// log.Printf("Wrote %d bytes.\n", bytesCopied)
 	if err != nil {
 		log.Printf("Failed to copy to rawConn.\n")
 		log.Fatal(err)
@@ -101,7 +109,7 @@
 		log.Fatal(err)
 		return -1, errors.New(errMsg)
 	}
-	log.Printf("cap(b): %d, len(b) %d, cap(out): %d, len(out): %d\n", cap(b), len(b), cap(out), len(out))
+	// log.Printf("cap(b): %d, len(b) %d, cap(out): %d, len(out): %d\n", cap(b), len(b), cap(out), len(out))
 	log.Printf("Succeeded in writing!\n\n")
 	// return int(bytesCopied), nil
 	return len(b), nil