diff --git a/.gitignore b/.gitignore
index 2058229..b7f764b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 addsvc/addsvc
+addsvc/client/addcli/addcli
 cover.out
 
 # Compiled Object files, Static and Dynamic libs (Shared Objects)
diff --git a/addsvc/add.go b/addsvc/add.go
index 83ecce8..c79f880 100644
--- a/addsvc/add.go
+++ b/addsvc/add.go
@@ -20,12 +20,12 @@
 // service.
 func proxyAdd(e endpoint.Endpoint, logger log.Logger) Add {
 	return func(ctx context.Context, a, b int64) int64 {
-		resp, err := e(ctx, &reqrep.AddRequest{A: a, B: b})
+		resp, err := e(ctx, reqrep.AddRequest{A: a, B: b})
 		if err != nil {
 			logger.Log("err", err)
 			return 0
 		}
-		addResp, ok := resp.(*reqrep.AddResponse)
+		addResp, ok := resp.(reqrep.AddResponse)
 		if !ok {
 			logger.Log("err", endpoint.ErrBadCast)
 			return 0
diff --git a/addsvc/client/addcli/main.go b/addsvc/client/addcli/main.go
new file mode 100644
index 0000000..4f01b04
--- /dev/null
+++ b/addsvc/client/addcli/main.go
@@ -0,0 +1,50 @@
+package main
+
+import (
+	"flag"
+	"log"
+	"os"
+	"time"
+
+	"github.com/go-kit/kit/addsvc/reqrep"
+	"github.com/go-kit/kit/endpoint"
+	"golang.org/x/net/context"
+
+	grpcclient "github.com/go-kit/kit/addsvc/client/grpc"
+
+	"google.golang.org/grpc"
+)
+
+func main() {
+	// Flag domain. Note that gRPC transitively registers flags via its import
+	// of glog. So, we define a new flag set, to keep those domains distinct.
+	fs := flag.NewFlagSet("", flag.ExitOnError)
+	var (
+		grpcAddr    = fs.String("grpc.addr", "localhost:8002", "gRPC address")
+		grpcTimeout = fs.Duration("grpc.timeout", 250*time.Millisecond, "gRPC dial timeout")
+		a           = fs.Int64("a", 1, "a value")
+		b           = fs.Int64("b", 2, "b value")
+	)
+	flag.Usage = fs.Usage // only show our flags
+	fs.Parse(os.Args[1:])
+	log.SetFlags(0)
+	log.SetOutput(os.Stdout)
+
+	cc, err := grpc.Dial(*grpcAddr, grpc.WithTimeout(*grpcTimeout))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var e endpoint.Endpoint = grpcclient.NewClient(cc)
+	response, err := e(context.Background(), reqrep.AddRequest{A: *a, B: *b})
+	if err != nil {
+		log.Fatalf("request: %v", err)
+	}
+
+	addResponse, ok := response.(reqrep.AddResponse)
+	if !ok {
+		log.Fatalf("response: %v", endpoint.ErrBadCast)
+	}
+
+	log.Print(addResponse.V)
+}
diff --git a/addsvc/client/grpc/client.go b/addsvc/client/grpc/client.go
new file mode 100644
index 0000000..33d80fe
--- /dev/null
+++ b/addsvc/client/grpc/client.go
@@ -0,0 +1,27 @@
+package grpc
+
+import (
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+
+	"github.com/go-kit/kit/addsvc/pb"
+	"github.com/go-kit/kit/addsvc/reqrep"
+	"github.com/go-kit/kit/endpoint"
+)
+
+// NewClient takes a gRPC ClientConn that should point to an instance of an
+// addsvc. It returns an endpoint that wraps and invokes that ClientConn.
+func NewClient(cc *grpc.ClientConn) endpoint.Endpoint {
+	client := pb.NewAddClient(cc)
+	return func(ctx context.Context, request interface{}) (interface{}, error) {
+		addReq, ok := request.(reqrep.AddRequest)
+		if !ok {
+			return nil, endpoint.ErrBadCast
+		}
+		reply, err := client.Add(ctx, &pb.AddRequest{A: addReq.A, B: addReq.B})
+		if err != nil {
+			return nil, err
+		}
+		return reqrep.AddResponse{V: reply.V}, nil
+	}
+}
diff --git a/addsvc/client/grpc/grpc_client.go b/addsvc/client/grpc/grpc_client.go
deleted file mode 100644
index 5066bf0..0000000
--- a/addsvc/client/grpc/grpc_client.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package grpc
-
-import (
-	"golang.org/x/net/context"
-	"google.golang.org/grpc"
-
-	"github.com/go-kit/kit/addsvc/pb"
-	"github.com/go-kit/kit/addsvc/reqrep"
-	"github.com/go-kit/kit/endpoint"
-)
-
-// NewClient takes a gRPC ClientConn that should point to an instance of an
-// addsvc. It returns an endpoint that wraps and invokes that ClientConn.
-func NewClient(cc *grpc.ClientConn) endpoint.Endpoint {
-	client := pb.NewAddClient(cc)
-	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		addReq, ok := request.(*reqrep.AddRequest)
-		if !ok {
-			return nil, endpoint.ErrBadCast
-		}
-		reply, err := client.Add(ctx, &pb.AddRequest{A: addReq.A, B: addReq.B})
-		if err != nil {
-			return nil, err
-		}
-		return &reqrep.AddResponse{V: reply.V}, nil
-	}
-}
diff --git a/addsvc/endpoint.go b/addsvc/endpoint.go
index 4626fca..ac31f3c 100644
--- a/addsvc/endpoint.go
+++ b/addsvc/endpoint.go
@@ -19,13 +19,14 @@
 			return nil, endpoint.ErrContextCanceled
 		}
 
-		addReq, ok := request.(*reqrep.AddRequest)
+		addReq, ok := request.(reqrep.AddRequest)
 		if !ok {
+			println("### 1")
 			return nil, endpoint.ErrBadCast
 		}
 
 		v := a(ctx, addReq.A, addReq.B)
 
-		return &reqrep.AddResponse{V: v}, nil
+		return reqrep.AddResponse{V: v}, nil
 	}
 }
diff --git a/addsvc/grpc_binding.go b/addsvc/grpc_binding.go
index 0bd423f..6420e53 100644
--- a/addsvc/grpc_binding.go
+++ b/addsvc/grpc_binding.go
@@ -21,20 +21,18 @@
 // way to manipulate the RPC context, like headers for HTTP. So we don't have
 // a way to transport e.g. Zipkin IDs with the request. TODO.
 func (b grpcBinding) Add(ctx context.Context, req *pb.AddRequest) (*pb.AddReply, error) {
-	addReq := &reqrep.AddRequest{A: req.A, B: req.B}
-	r, err := b.Endpoint(ctx, addReq)
+	r, err := b.Endpoint(ctx, reqrep.AddRequest{A: req.A, B: req.B})
 	if err != nil {
 		return nil, err
 	}
 
-	resp, ok := r.(*reqrep.AddResponse)
+	resp, ok := r.(reqrep.AddResponse)
 	if !ok {
+		println("### 2")
 		return nil, endpoint.ErrBadCast
 	}
 
-	return &pb.AddReply{
-		V: resp.V,
-	}, nil
+	return &pb.AddReply{V: resp.V}, nil
 }
 
 func grpcInstrument(requests metrics.Counter, duration metrics.Histogram) func(pb.AddServer) pb.AddServer {