diff --git a/.circleci/config.yml b/.circleci/config.yml
index c92d5c8091..3bfa765f4f 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -67,7 +67,7 @@ jobs:
       - install-bazel-linux-rbe
       - checkout
       - run-bazel-rbe:
-          command: bazel test //concept/test/... --test_output=errors
+          command: bazel test //test/behaviour/concept:concept-it --test_output=errors
 
   test-keyspace:
     machine: true
diff --git a/BUILD b/BUILD
index 95f3943554..c10102e252 100644
--- a/BUILD
+++ b/BUILD
@@ -28,6 +28,7 @@ exports_files(["VERSION", "RELEASE_TEMPLATE.md", "deployment.properties"])
 java_library(
     name = "client-java",
     srcs = glob([
+        "answer/*.java",
         "concept/*.java",
         "exception/*.java",
         "rpc/*.java",
@@ -38,8 +39,6 @@ java_library(
         # External dependencies from @graknlabs
         "@graknlabs_graql//java:graql",
         "@graknlabs_protocol//grpc/java:protocol",
-        "@graknlabs_grakn_core//api:api",
-        "@graknlabs_grakn_core//concept:concept",
 
         # External dependencies from Maven
         "//dependencies/maven/artifacts/com/google/code/findbugs:jsr305",
diff --git a/GraknClient.java b/GraknClient.java
index 89084a3c8b..dc5e73879e 100644
--- a/GraknClient.java
+++ b/GraknClient.java
@@ -21,33 +21,34 @@
 
 import com.google.common.collect.AbstractIterator;
 import com.google.common.collect.ImmutableList;
-import grakn.client.concept.RemoteConcept;
+import grakn.client.concept.Attribute;
+import grakn.client.concept.AttributeType;
+import grakn.client.concept.Concept;
+import grakn.client.concept.ConceptId;
+import grakn.client.concept.EntityType;
+import grakn.client.concept.Label;
+import grakn.client.concept.RelationType;
+import grakn.client.concept.Role;
+import grakn.client.concept.Rule;
+import grakn.client.concept.SchemaConcept;
+import grakn.client.answer.Answer;
+import grakn.client.answer.AnswerGroup;
+import grakn.client.answer.ConceptList;
+import grakn.client.answer.ConceptMap;
+import grakn.client.answer.ConceptSet;
+import grakn.client.answer.ConceptSetMeasure;
+import grakn.client.answer.Numeric;
 import grakn.client.exception.GraknClientException;
 import grakn.client.rpc.RequestBuilder;
 import grakn.client.rpc.ResponseReader;
 import grakn.client.rpc.Transceiver;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.Label;
-import grakn.core.concept.answer.AnswerGroup;
-import grakn.core.concept.answer.ConceptList;
-import grakn.core.concept.answer.ConceptMap;
-import grakn.core.concept.answer.ConceptSet;
-import grakn.core.concept.answer.ConceptSetMeasure;
-import grakn.core.concept.answer.Numeric;
-import grakn.core.concept.thing.Attribute;
-import grakn.core.concept.type.AttributeType;
-import grakn.core.concept.type.EntityType;
-import grakn.core.concept.type.RelationType;
-import grakn.core.concept.type.Role;
-import grakn.core.concept.type.Rule;
-import grakn.core.concept.type.SchemaConcept;
 import grakn.protocol.keyspace.KeyspaceProto;
 import grakn.protocol.keyspace.KeyspaceServiceGrpc;
 import grakn.protocol.keyspace.KeyspaceServiceGrpc.KeyspaceServiceBlockingStub;
 import grakn.protocol.session.ConceptProto;
 import grakn.protocol.session.SessionProto;
 import grakn.protocol.session.SessionServiceGrpc;
+import graql.lang.Graql;
 import graql.lang.pattern.Pattern;
 import graql.lang.query.GraqlCompute;
 import graql.lang.query.GraqlDefine;
@@ -64,21 +65,17 @@
 import javax.annotation.Nullable;
 import java.io.Serializable;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
-import static java.util.stream.Collectors.collectingAndThen;
-import static java.util.stream.Collectors.toSet;
-
 /**
  * Entry-point which communicates with a running Grakn server using gRPC.
- * For now, only a subset of grakn.core.api.Session and grakn.core.api.Transaction features are supported.
  */
 public class GraknClient implements AutoCloseable {
 
@@ -110,7 +107,7 @@ public GraknClient overrideChannel(ManagedChannel channel) {
         return this;
     }
 
-    @Override
+
     public void close() {
         channel.shutdown();
         try {
@@ -133,12 +130,10 @@ public Keyspaces keyspaces() {
     }
 
     /**
-     * Remote implementation of grakn.core.api.Session that communicates with a Grakn server using gRPC.
-     *
      * @see Transaction
      * @see GraknClient
      */
-    public static class Session implements grakn.core.api.Session {
+    public static class Session {
 
         protected ManagedChannel channel;
         private String username; // TODO: Do we need to save this? It's not used.
@@ -169,7 +164,6 @@ private Session(ManagedChannel channel, String username, String password, String
             isOpen = true;
         }
 
-        @Override
         public GraknClient.Transaction.Builder transaction() {
             return new Transaction.Builder(channel, this, sessionId);
         }
@@ -178,28 +172,23 @@ public boolean isOpen() {
             return isOpen;
         }
 
-        @Override
         public void close() {
             if (!isOpen) return;
             sessionStub.close(RequestBuilder.Session.close(sessionId));
             isOpen = false;
         }
 
-        @Override // TODO: remove this method once we no longer implement grakn.core.api.Session
         public Keyspace keyspace() {
             return Keyspace.of(keyspace);
         }
     }
 
-    /**
-     * Remote implementation of grakn.core.api.Transaction that communicates with a Grakn server using gRPC.
-     */
-    public static class Transaction implements grakn.core.api.Transaction {
+    public static class Transaction implements AutoCloseable {
         private final Session session;
         private final Type type;
         private final Transceiver transceiver;
 
-        public static class Builder implements grakn.core.api.Transaction.Builder {
+        public static class Builder {
 
             private ManagedChannel channel;
             private GraknClient.Session session;
@@ -211,12 +200,10 @@ public Builder(ManagedChannel channel, GraknClient.Session session, String sessi
                 this.sessionId = sessionId;
             }
 
-            @Override
             public GraknClient.Transaction read() {
                 return new GraknClient.Transaction(channel, session, sessionId, Transaction.Type.READ);
             }
 
-            @Override
             public GraknClient.Transaction write() {
                 return new GraknClient.Transaction(channel, session, sessionId, Transaction.Type.WRITE);
             }
@@ -257,50 +244,126 @@ private Transaction(ManagedChannel channel, Session session, String sessionId, T
             responseOrThrow();
         }
 
-        @Override // TODO: Replace return type with GraknClient.Transaction.Type once we resolve graknlabs/grakn#5289
-        public grakn.core.api.Transaction.Type type() {
-            return grakn.core.api.Transaction.Type.of(type.id());
+        public Type type() {
+            return type;
         }
 
-        @Override
         public GraknClient.Session session() {
             return session;
         }
 
-        @Override
         public Keyspace keyspace() {
             return session.keyspace();
         }
 
-        @Override
+        public List<ConceptMap> execute(GraqlDefine query) {
+            return stream(query).collect(Collectors.toList());
+        }
+
+        public List<ConceptMap> execute(GraqlUndefine query) {
+            return stream(query).collect(Collectors.toList());
+        }
+
+        public List<ConceptMap> execute(GraqlInsert query, boolean infer) {
+            return stream(query, infer).collect(Collectors.toList());
+        }
+        public List<ConceptMap> execute(GraqlInsert query) {
+            return stream(query).collect(Collectors.toList());
+        }
+
+        public List<ConceptSet> execute(GraqlDelete query, boolean infer) {
+            return stream(query, infer).collect(Collectors.toList());
+        }
+        public List<ConceptSet> execute(GraqlDelete query) {
+            return stream(query).collect(Collectors.toList());
+        }
+
+        public List<ConceptMap> execute(GraqlGet query, boolean infer) {
+            return stream(query, infer).collect(Collectors.toList());
+        }
+        public List<ConceptMap> execute(GraqlGet query) {
+            return stream(query).collect(Collectors.toList());
+        }
+
         public Stream<ConceptMap> stream(GraqlDefine query) {
             Iterable<ConceptMap> iterable = () -> this.rpcIterator(query);
             return StreamSupport.stream(iterable.spliterator(), false);
         }
 
-        @Override
         public Stream<ConceptMap> stream(GraqlUndefine query) {
             Iterable<ConceptMap> iterable = () -> this.rpcIterator(query);
             return StreamSupport.stream(iterable.spliterator(), false);
         }
 
-        @Override
         public Stream<ConceptMap> stream(GraqlInsert query, boolean infer) {
             Iterable<ConceptMap> iterable = () -> this.rpcIterator(query, infer);
             return StreamSupport.stream(iterable.spliterator(), false);
         }
+        public Stream<ConceptMap> stream(GraqlInsert query) {
+            return stream(query, true);
+        }
 
-        @Override
         public Stream<ConceptSet> stream(GraqlDelete query, boolean infer) {
             Iterable<ConceptSet> iterable = () -> this.rpcIterator(query, infer);
             return StreamSupport.stream(iterable.spliterator(), false);
         }
+        public Stream<ConceptSet> stream(GraqlDelete query) {
+            return stream(query, true);
+        }
 
-        @Override
         public Stream<ConceptMap> stream(GraqlGet query, boolean infer) {
             Iterable<ConceptMap> iterable = () -> this.rpcIterator(query, infer);
             return StreamSupport.stream(iterable.spliterator(), false);
         }
+        public Stream<ConceptMap> stream(GraqlGet query) {
+            return stream(query, true);
+        }
+
+        public Stream<? extends Answer> stream(GraqlQuery query) {
+            return stream(query, true);
+        }
+
+        public Stream<? extends Answer> stream(GraqlQuery query, boolean infer) {
+            if (query instanceof GraqlDefine) {
+                return stream((GraqlDefine) query);
+
+            } else if (query instanceof GraqlUndefine) {
+                return stream((GraqlUndefine) query);
+
+            } else if (query instanceof GraqlInsert) {
+                return stream((GraqlInsert) query, infer);
+
+            } else if (query instanceof GraqlDelete) {
+                return stream((GraqlDelete) query, infer);
+
+            } else if (query instanceof GraqlGet) {
+                return stream((GraqlGet) query, infer);
+
+            } else if (query instanceof GraqlGet.Aggregate) {
+                return stream((GraqlGet.Aggregate) query, infer);
+
+            } else if (query instanceof GraqlGet.Group.Aggregate) {
+                return stream((GraqlGet.Group.Aggregate) query, infer);
+
+            } else if (query instanceof GraqlGet.Group) {
+                return stream((GraqlGet.Group) query, infer);
+
+            } else if (query instanceof GraqlCompute.Statistics) {
+                return stream((GraqlCompute.Statistics) query);
+
+            } else if (query instanceof GraqlCompute.Path) {
+                return stream((GraqlCompute.Path) query);
+
+            } else if (query instanceof GraqlCompute.Centrality) {
+                return stream((GraqlCompute.Centrality) query);
+
+            } else if (query instanceof GraqlCompute.Cluster) {
+                return stream((GraqlCompute.Cluster) query);
+
+            } else {
+                throw new IllegalArgumentException("Unrecognised Query object");
+            }
+        }
 
         private Iterator rpcIterator(GraqlQuery query) {
             return rpcIterator(query, true);
@@ -317,20 +380,23 @@ private Iterator rpcIterator(GraqlQuery query, boolean infer) {
             );
         }
 
-        @Override
-        public void close() {
-            transceiver.close();
+        public void abort() {
+            close();
         }
 
-        @Override // TODO: Remove this method once we resolve graknlabs/grakn#5289
-        public boolean isClosed() {
-            return !transceiver.isOpen();
+        public void close() {
+            transceiver.close();
         }
 
         public boolean isOpen() {
             return transceiver.isOpen();
         }
 
+        // TODO remove - backwards compatibility
+        public boolean isClosed() {
+            return !isOpen();
+        }
+
         private SessionProto.Transaction.Res responseOrThrow() {
             Transceiver.Response response;
 
@@ -357,7 +423,6 @@ private SessionProto.Transaction.Res responseOrThrow() {
             }
         }
 
-        @Override
         public void commit() {
             transceiver.send(RequestBuilder.Transaction.commit());
             responseOrThrow();
@@ -365,15 +430,13 @@ public void commit() {
         }
 
         @Nullable
-        @Override
-        public <T extends grakn.core.concept.type.Type> T getType(Label label) {
+        public <T extends grakn.client.concept.Type> T getType(Label label) {
             SchemaConcept concept = getSchemaConcept(label);
             if (concept == null || !concept.isType()) return null;
             return (T) concept.asType();
         }
 
         @Nullable
-        @Override
         public EntityType getEntityType(String label) {
             SchemaConcept concept = getSchemaConcept(Label.of(label));
             if (concept == null || !concept.isEntityType()) return null;
@@ -381,7 +444,6 @@ public EntityType getEntityType(String label) {
         }
 
         @Nullable
-        @Override
         public RelationType getRelationType(String label) {
             SchemaConcept concept = getSchemaConcept(Label.of(label));
             if (concept == null || !concept.isRelationType()) return null;
@@ -389,7 +451,6 @@ public RelationType getRelationType(String label) {
         }
 
         @Nullable
-        @Override
         public <V> AttributeType<V> getAttributeType(String label) {
             SchemaConcept concept = getSchemaConcept(Label.of(label));
             if (concept == null || !concept.isAttributeType()) return null;
@@ -397,7 +458,6 @@ public <V> AttributeType<V> getAttributeType(String label) {
         }
 
         @Nullable
-        @Override
         public Role getRole(String label) {
             SchemaConcept concept = getSchemaConcept(Label.of(label));
             if (concept == null || !concept.isRole()) return null;
@@ -405,7 +465,6 @@ public Role getRole(String label) {
         }
 
         @Nullable
-        @Override
         public Rule getRule(String label) {
             SchemaConcept concept = getSchemaConcept(Label.of(label));
             if (concept == null || !concept.isRule()) return null;
@@ -413,7 +472,6 @@ public Rule getRule(String label) {
         }
 
         @Nullable
-        @Override
         public <T extends SchemaConcept> T getSchemaConcept(Label label) {
             transceiver.send(RequestBuilder.Transaction.getSchemaConcept(label));
             SessionProto.Transaction.Res response = responseOrThrow();
@@ -421,12 +479,15 @@ public <T extends SchemaConcept> T getSchemaConcept(Label label) {
                 case NULL:
                     return null;
                 default:
-                    return (T) RemoteConcept.of(response.getGetSchemaConceptRes().getSchemaConcept(), this).asSchemaConcept();
+                    return (T) Concept.of(response.getGetSchemaConceptRes().getSchemaConcept(), this).asSchemaConcept();
             }
         }
 
+        public SchemaConcept getMetaConcept() {
+            return getSchemaConcept(Label.of(Graql.Token.Type.THING.toString()));
+        }
+
         @Nullable
-        @Override
         public <T extends Concept> T getConcept(ConceptId id) {
             transceiver.send(RequestBuilder.Transaction.getConcept(id));
             SessionProto.Transaction.Res response = responseOrThrow();
@@ -434,95 +495,93 @@ public <T extends Concept> T getConcept(ConceptId id) {
                 case NULL:
                     return null;
                 default:
-                    return (T) RemoteConcept.of(response.getGetConceptRes().getConcept(), this);
+                    return (T) Concept.of(response.getGetConceptRes().getConcept(), this);
             }
         }
 
-        @Override
         public <V> Collection<Attribute<V>> getAttributesByValue(V value) {
             transceiver.send(RequestBuilder.Transaction.getAttributes(value));
             int iteratorId = responseOrThrow().getGetAttributesIter().getId();
-            Iterable<Concept> iterable = () -> new RPCIterator<>(
-                    this, iteratorId, response -> RemoteConcept.of(response.getGetAttributesIterRes().getAttribute(), this)
+            Iterable<Attribute<V>> iterable = () -> new RPCIterator<Attribute<V>>(
+                    this, iteratorId, response -> Concept.of(response.getGetAttributesIterRes().getAttribute(), this).asAttribute()
             );
 
-            return StreamSupport.stream(iterable.spliterator(), false).map(Concept::<V>asAttribute)
-                    .collect(collectingAndThen(toSet(), Collections::unmodifiableSet));
+            return StreamSupport.stream(iterable.spliterator(), false)
+                    .collect(Collectors.toSet());
         }
 
-        @Override
         public EntityType putEntityType(Label label) {
             transceiver.send(RequestBuilder.Transaction.putEntityType(label));
-            return RemoteConcept.of(responseOrThrow().getPutEntityTypeRes().getEntityType(), this).asEntityType();
+            return Concept.of(responseOrThrow().getPutEntityTypeRes().getEntityType(), this).asEntityType();
         }
 
-        @Override
+
         public <V> AttributeType<V> putAttributeType(Label label, AttributeType.DataType<V> dataType) {
             transceiver.send(RequestBuilder.Transaction.putAttributeType(label, dataType));
-            return RemoteConcept.of(responseOrThrow().getPutAttributeTypeRes().getAttributeType(), this).asAttributeType();
+            return Concept.of(responseOrThrow().getPutAttributeTypeRes().getAttributeType(), this).asAttributeType();
         }
 
-        @Override
+
         public RelationType putRelationType(Label label) {
             transceiver.send(RequestBuilder.Transaction.putRelationType(label));
-            return RemoteConcept.of(responseOrThrow().getPutRelationTypeRes().getRelationType(), this).asRelationType();
+            return Concept.of(responseOrThrow().getPutRelationTypeRes().getRelationType(), this).asRelationType();
         }
 
-        @Override
+
         public Role putRole(Label label) {
             transceiver.send(RequestBuilder.Transaction.putRole(label));
-            return RemoteConcept.of(responseOrThrow().getPutRoleRes().getRole(), this).asRole();
+            return Concept.of(responseOrThrow().getPutRoleRes().getRole(), this).asRole();
         }
 
-        @Override
+
         public Rule putRule(Label label, Pattern when, Pattern then) {
             transceiver.send(RequestBuilder.Transaction.putRule(label, when, then));
-            return RemoteConcept.of(responseOrThrow().getPutRuleRes().getRule(), this).asRule();
+            return Concept.of(responseOrThrow().getPutRuleRes().getRule(), this).asRule();
         }
 
-        @Override
+
         public Stream<Numeric> stream(GraqlGet.Aggregate query, boolean infer) {
             Iterable<Numeric> iterable = () -> rpcIterator(query, infer);
             return StreamSupport.stream(iterable.spliterator(), false);
         }
 
-        @Override
+
         public Stream<AnswerGroup<ConceptMap>> stream(GraqlGet.Group query, boolean infer) {
             Iterable<AnswerGroup<ConceptMap>> iterable = () -> rpcIterator(query, infer);
             return StreamSupport.stream(iterable.spliterator(), false);
         }
 
-        @Override
+
         public Stream<AnswerGroup<Numeric>> stream(GraqlGet.Group.Aggregate query, boolean infer) {
             Iterable<AnswerGroup<Numeric>> iterable = () -> rpcIterator(query, infer);
             return StreamSupport.stream(iterable.spliterator(), false);
         }
 
-        @Override
+
         public Stream<Numeric> stream(GraqlCompute.Statistics query) {
             Iterable<Numeric> iterable = () -> rpcIterator(query, false);
             return StreamSupport.stream(iterable.spliterator(), false);
         }
 
-        @Override
+
         public Stream<ConceptList> stream(GraqlCompute.Path query) {
             Iterable<ConceptList> iterable = () -> rpcIterator(query, false);
             return StreamSupport.stream(iterable.spliterator(), false);
         }
 
-        @Override
+
         public Stream<ConceptSetMeasure> stream(GraqlCompute.Centrality query) {
             Iterable<ConceptSetMeasure> iterable = () -> rpcIterator(query, false);
             return StreamSupport.stream(iterable.spliterator(), false);
         }
 
-        @Override
+
         public Stream<ConceptSet> stream(GraqlCompute.Cluster query) {
             Iterable<ConceptSet> iterable = () -> rpcIterator(query, false);
             return StreamSupport.stream(iterable.spliterator(), false);
         }
 
-        @Override
+
         public Stream<SchemaConcept> sups(SchemaConcept schemaConcept) {
             ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                     .setSchemaConceptSupsReq(ConceptProto.SchemaConcept.Sups.Req.getDefaultInstance()).build();
@@ -531,7 +590,7 @@ public Stream<SchemaConcept> sups(SchemaConcept schemaConcept) {
             int iteratorId = response.getConceptMethodRes().getResponse().getSchemaConceptSupsIter().getId();
 
             Iterable<? extends Concept> iterable = () -> new RPCIterator<>(
-                    this, iteratorId, res -> RemoteConcept.of(res.getConceptMethodIterRes().getSchemaConceptSupsIterRes().getSchemaConcept(), this)
+                    this, iteratorId, res -> Concept.of(res.getConceptMethodIterRes().getSchemaConceptSupsIterRes().getSchemaConcept(), this)
             );
 
             Stream<? extends Concept> sups = StreamSupport.stream(iterable.spliterator(), false);
@@ -573,7 +632,7 @@ private RPCIterator(Transaction tx, int iteratorId, Function<SessionProto.Transa
                 this.responseReader = responseReader;
             }
 
-            @Override
+
             protected final T computeNext() {
                 SessionProto.Transaction.Iter.Res response = tx.iterate(iteratorId);
 
@@ -607,7 +666,7 @@ public static final class Keyspaces {
 
         public void delete(String name) {
             try {
-                KeyspaceProto.Keyspace.Delete.Req request = RequestBuilder.Keyspace.delete(name, this.username, this.password);
+                KeyspaceProto.Keyspace.Delete.Req request = RequestBuilder.KeyspaceMessage.delete(name, this.username, this.password);
                 keyspaceBlockingStub.delete(request);
             } catch (StatusRuntimeException e) {
                 throw GraknClientException.create(e.getMessage(), e);
@@ -616,7 +675,7 @@ public void delete(String name) {
 
         public List<String> retrieve() {
             try {
-                KeyspaceProto.Keyspace.Retrieve.Req request = RequestBuilder.Keyspace.retrieve(this.username, this.password);
+                KeyspaceProto.Keyspace.Retrieve.Req request = RequestBuilder.KeyspaceMessage.retrieve(this.username, this.password);
                 return ImmutableList.copyOf(keyspaceBlockingStub.retrieve(request).getNamesList().iterator());
             } catch (StatusRuntimeException e) {
                 throw GraknClientException.create(e.getMessage(), e);
@@ -627,7 +686,7 @@ public List<String> retrieve() {
     /**
      * An identifier for an isolated scope of a data in the database.
      */
-    public static class Keyspace implements grakn.core.api.Keyspace, Serializable {
+    public static class Keyspace implements Serializable {
 
         private static final long serialVersionUID = 2726154016735929123L;
         public static final String DEFAULT = "grakn";
@@ -651,12 +710,10 @@ public String name() {
             return name;
         }
 
-        @Override
         public final String toString() {
             return name();
         }
 
-        @Override
         public boolean equals(Object o) {
             if (this == o) return true;
             if (o == null || getClass() != o.getClass()) return false;
@@ -665,7 +722,6 @@ public boolean equals(Object o) {
             return this.name.equals(that.name);
         }
 
-        @Override
         public int hashCode() {
             int h = 1;
             h *= 1000003;
diff --git a/answer/Answer.java b/answer/Answer.java
new file mode 100644
index 0000000000..e02345fd0a
--- /dev/null
+++ b/answer/Answer.java
@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package grakn.client.answer;
+
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nullable;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * An object that contains the answer of every Graql Query.
+ */
+public abstract class Answer {
+
+    /**
+     * @return an explanation object indicating how this answer was obtained
+     */
+    @Nullable
+    @CheckReturnValue
+    public abstract Explanation explanation();
+
+    /**
+     * @return all explanations taking part in the derivation of this answer
+     */
+    @CheckReturnValue
+    public Set<Explanation> explanations() {
+        if (this.explanation() == null) return Collections.emptySet();
+        Set<Explanation> explanations = new HashSet<>();
+        explanations.add(this.explanation());
+        this.explanation().getAnswers().forEach(ans -> explanations.addAll(ans.explanations()));
+        return explanations;
+    }
+}
diff --git a/answer/AnswerGroup.java b/answer/AnswerGroup.java
new file mode 100644
index 0000000000..5d71c8e04f
--- /dev/null
+++ b/answer/AnswerGroup.java
@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package grakn.client.answer;
+
+import grakn.client.concept.Concept;
+
+import javax.annotation.Nullable;
+import java.util.List;
+
+/**
+ * A type of Answer object that contains a List of Answers as the members and a RemoteConcept
+ * as the owner.
+ *
+ * @param <T> the type of Answer being grouped
+ */
+public class AnswerGroup<T extends Answer> extends Answer {
+
+    private final Concept owner;
+    private final List<T> answers;
+    private final Explanation explanation;
+
+    public AnswerGroup(Concept owner, List<T> answers) {
+        this(owner, answers, new Explanation());
+    }
+
+    public AnswerGroup(Concept owner, List<T> answers, Explanation explanation) {
+        this.owner = owner;
+        this.answers = answers;
+        this.explanation = explanation;
+    }
+
+    @Nullable
+    @Override
+    public Explanation explanation() {
+        return explanation;
+    }
+
+    public Concept owner() {
+        return this.owner;
+    }
+
+    public List<T> answers() {
+        return this.answers;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        AnswerGroup a2 = (AnswerGroup) obj;
+        return this.owner.equals(a2.owner) &&
+                this.answers.equals(a2.answers);
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = owner.hashCode();
+        hash = 31 * hash + answers.hashCode();
+
+        return hash;
+    }
+}
diff --git a/answer/ConceptList.java b/answer/ConceptList.java
new file mode 100644
index 0000000000..e70ff815bc
--- /dev/null
+++ b/answer/ConceptList.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package grakn.client.answer;
+
+import grakn.client.concept.ConceptId;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A type of Answer object that contains a List of Concepts.
+ */
+public class ConceptList extends Answer {
+
+    // TODO: change to store List<Concept> once we are able to construct Concept without a database look up
+    private final List<ConceptId> list;
+    private final Explanation explanation;
+
+    public ConceptList(List<ConceptId> list) {
+        this.list = Collections.unmodifiableList(list);
+        this.explanation = new Explanation();
+    }
+
+    @Override
+    public Explanation explanation() {
+        return explanation;
+    }
+
+    public List<ConceptId> list() {
+        return list;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        ConceptList a2 = (ConceptList) obj;
+        return this.list.equals(a2.list);
+    }
+
+    @Override
+    public int hashCode() {
+        return list.hashCode();
+    }
+}
diff --git a/answer/ConceptMap.java b/answer/ConceptMap.java
new file mode 100644
index 0000000000..946c871140
--- /dev/null
+++ b/answer/ConceptMap.java
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package grakn.client.answer;
+
+import grakn.client.concept.Concept;
+import grakn.client.concept.GraknConceptException;
+import graql.lang.statement.Variable;
+
+import javax.annotation.CheckReturnValue;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+
+/**
+ * A type of Answer object that contains a Map of Concepts.
+ */
+public class ConceptMap extends Answer {
+
+    private final Map<Variable, Concept> map;
+    private final Explanation explanation;
+
+    public ConceptMap(Map<Variable, Concept> map, Explanation exp) {
+        this.map = Collections.unmodifiableMap(map);
+        this.explanation = exp;
+    }
+
+    @Override
+    public Explanation explanation() {
+        return explanation;
+    }
+
+    @CheckReturnValue
+    public Map<Variable, Concept> map() {
+        return map;
+    }
+
+
+    @CheckReturnValue
+    public Concept get(String variable) {
+        Variable var = new Variable(variable);
+        Concept Concept = map.get(var);
+        if (Concept == null) throw GraknConceptException.variableDoesNotExist(var.toString());
+        return Concept;
+    }
+
+    @Override
+    public String toString() {
+        return map.entrySet().stream()
+                .sorted(Comparator.comparing(e -> e.getKey().name()))
+                .map(e -> "[" + e.getKey() + "/" + e.getValue().id() + "]").collect(Collectors.joining());
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        ConceptMap a2 = (ConceptMap) obj;
+        return map.equals(a2.map);
+    }
+
+    @Override
+    public int hashCode() { return map.hashCode();}
+}
diff --git a/answer/ConceptSet.java b/answer/ConceptSet.java
new file mode 100644
index 0000000000..2d2fb6620d
--- /dev/null
+++ b/answer/ConceptSet.java
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package grakn.client.answer;
+
+import grakn.client.concept.ConceptId;
+
+import java.util.Collections;
+import java.util.Set;
+
+/**
+ * A type of Answer object that contains a Set.
+ */
+public class ConceptSet extends Answer {
+
+    // TODO: change to store Set<Concept> once we are able to construct Concept without a database look up
+    private final Set<ConceptId> set;
+    private final Explanation explanation;
+
+    public ConceptSet(Set<ConceptId> set) {
+        this(set, new Explanation());
+    }
+
+    public ConceptSet(Set<ConceptId> set, Explanation explanation) {
+        this.set = Collections.unmodifiableSet(set);
+        this.explanation = explanation;
+    }
+
+    @Override
+    public Explanation explanation() {
+        return explanation;
+    }
+
+    public Set<ConceptId> set() {
+        return set;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        ConceptSet a2 = (ConceptSet) obj;
+        return this.set.equals(a2.set);
+    }
+
+    @Override
+    public int hashCode() {
+        return set.hashCode();
+    }
+}
diff --git a/answer/ConceptSetMeasure.java b/answer/ConceptSetMeasure.java
new file mode 100644
index 0000000000..1965d934a8
--- /dev/null
+++ b/answer/ConceptSetMeasure.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package grakn.client.answer;
+
+import grakn.client.concept.ConceptId;
+
+import java.util.Set;
+
+/**
+ * A type of Answer object that contains a Set and Number, by extending RemoteConceptSet.
+ */
+public class ConceptSetMeasure extends ConceptSet {
+
+    private final Number measurement;
+
+    public ConceptSetMeasure(Set<ConceptId> set, Number measurement) {
+        this(set, measurement, new Explanation());
+    }
+
+    public ConceptSetMeasure(Set<ConceptId> set, Number measurement, Explanation explanation) {
+        super(set, explanation);
+        this.measurement = measurement;
+    }
+
+    public Number measurement() {
+        return measurement;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        ConceptSetMeasure a2 = (ConceptSetMeasure) obj;
+        return this.set().equals(a2.set())
+                && measurement.toString().equals(a2.measurement.toString());
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = super.hashCode();
+        hash = 31 * hash + measurement.hashCode();
+
+        return hash;
+    }
+}
diff --git a/answer/Explanation.java b/answer/Explanation.java
new file mode 100644
index 0000000000..a2a8475120
--- /dev/null
+++ b/answer/Explanation.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package grakn.client.answer;
+
+import graql.lang.pattern.Pattern;
+
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nullable;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Reasoner explanation for inferred answers
+ */
+public class Explanation {
+
+    private final Pattern pattern;
+    private final List<ConceptMap> answers;
+
+    public Explanation() {
+        this.pattern = null;
+        this.answers = Collections.unmodifiableList(Collections.emptyList());
+    }
+
+    public Explanation(Pattern pattern, List<ConceptMap> ans) {
+        this.pattern = pattern;
+        this.answers = Collections.unmodifiableList(ans);
+    }
+
+    /**
+     * @return query pattern associated with this explanation
+     */
+    @CheckReturnValue
+    @Nullable
+    public Pattern getPattern() { return pattern;}
+
+    /**
+     * @return answers this explanation is dependent on
+     */
+    @CheckReturnValue
+    public List<ConceptMap> getAnswers() { return answers;}
+}
diff --git a/answer/Numeric.java b/answer/Numeric.java
new file mode 100644
index 0000000000..4c5e02ce71
--- /dev/null
+++ b/answer/Numeric.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package grakn.client.answer;
+
+/**
+ * A type of Answer object that contains a Number.
+ */
+public class Numeric extends Answer {
+
+    private final Number number;
+    private final Explanation explanation;
+
+    public Numeric(Number number) {
+        this(number, new Explanation());
+    }
+
+    public Numeric(Number number, Explanation explanation) {
+        this.number = number;
+        this.explanation = explanation;
+    }
+
+    @Override
+    public Explanation explanation() {
+        return explanation;
+    }
+
+    public Number number() {
+        return number;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        Numeric a2 = (Numeric) obj;
+        return this.number.toString().equals(a2.number.toString());
+    }
+
+    @Override
+    public int hashCode() {
+        return number.hashCode();
+    }
+}
diff --git a/concept/RemoteAttribute.java b/concept/Attribute.java
similarity index 83%
rename from concept/RemoteAttribute.java
rename to concept/Attribute.java
index 549b7222aa..afa7c135d4 100644
--- a/concept/RemoteAttribute.java
+++ b/concept/Attribute.java
@@ -20,13 +20,9 @@
 package grakn.client.concept;
 
 import grakn.client.GraknClient;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.thing.Attribute;
-import grakn.core.concept.thing.Thing;
-import grakn.core.concept.type.AttributeType;
 import grakn.protocol.session.ConceptProto;
 
+import javax.annotation.CheckReturnValue;
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
@@ -37,17 +33,12 @@
  *
  * @param <D> The data type of this attribute
  */
-public class RemoteAttribute<D> extends RemoteThing<Attribute<D>, AttributeType<D>> implements Attribute<D> {
+public class Attribute<D> extends Thing<Attribute, AttributeType<D>> {
 
-    RemoteAttribute(GraknClient.Transaction tx, ConceptId id) {
+    Attribute(GraknClient.Transaction tx, ConceptId id) {
         super(tx, id);
     }
 
-    static <D> RemoteAttribute<D> construct(GraknClient.Transaction tx, ConceptId id) {
-        return new RemoteAttribute<>(tx, id);
-    }
-
-    @Override
     public final D value() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setAttributeValueReq(ConceptProto.Attribute.Value.Req.getDefaultInstance()).build();
@@ -80,7 +71,6 @@ private D castValue(ConceptProto.ValueObject value) {
         }
     }
 
-    @Override
     public final Stream<Thing> owners() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setAttributeOwnersReq(ConceptProto.Attribute.Owners.Req.getDefaultInstance()).build();
@@ -89,18 +79,30 @@ public final Stream<Thing> owners() {
         return conceptStream(iteratorId, res -> res.getAttributeOwnersIterRes().getThing()).map(Concept::asThing);
     }
 
-    @Override
     public final AttributeType.DataType<D> dataType() {
         return type().dataType();
     }
 
-    @Override
     final AttributeType<D> asCurrentType(Concept concept) {
         return concept.asAttributeType();
     }
 
-    @Override
-    final Attribute<D> asCurrentBaseType(Concept other) {
+    final Attribute asCurrentBaseType(Concept other) {
         return other.asAttribute();
     }
+
+    @SuppressWarnings("unchecked")
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public Attribute asAttribute() {
+        return this;
+    }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public boolean isAttribute() {
+        return true;
+    }
 }
diff --git a/concept/RemoteAttributeType.java b/concept/AttributeType.java
similarity index 57%
rename from concept/RemoteAttributeType.java
rename to concept/AttributeType.java
index cd07eb44b8..4699fb017d 100644
--- a/concept/RemoteAttributeType.java
+++ b/concept/AttributeType.java
@@ -22,59 +22,50 @@
 import grakn.client.GraknClient;
 import grakn.client.exception.GraknClientException;
 import grakn.client.rpc.RequestBuilder;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.thing.Attribute;
-import grakn.core.concept.type.AttributeType;
 import grakn.protocol.session.ConceptProto;
 
+import javax.annotation.CheckReturnValue;
 import javax.annotation.Nullable;
+import java.time.LocalDateTime;
 
 /**
  * Client implementation of AttributeType
  *
  * @param <D> The data type of this attribute type
  */
-public class RemoteAttributeType<D> extends RemoteType<AttributeType<D>, Attribute<D>> implements AttributeType<D> {
+public class AttributeType<D> extends Type<AttributeType, Attribute<D>> {
 
-    RemoteAttributeType(GraknClient.Transaction tx, ConceptId id) {
+    AttributeType(GraknClient.Transaction tx, ConceptId id) {
         super(tx, id);
     }
 
-    static <D> RemoteAttributeType<D> construct(GraknClient.Transaction tx, ConceptId id) {
-        return new RemoteAttributeType<>(tx, id);
-    }
-
-    @Override
     public final Attribute<D> create(D value) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setAttributeTypeCreateReq(ConceptProto.AttributeType.Create.Req.newBuilder()
-                                                   .setValue(RequestBuilder.Concept.attributeValue(value))).build();
+                                                   .setValue(RequestBuilder.ConceptMessage.attributeValue(value))).build();
 
-        Concept concept = RemoteConcept.of(runMethod(method).getAttributeTypeCreateRes().getAttribute(), tx());
+        Concept concept = Concept.of(runMethod(method).getAttributeTypeCreateRes().getAttribute(), tx());
         return asInstance(concept);
     }
 
     @Nullable
-    @Override
     public final Attribute<D> attribute(D value) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setAttributeTypeAttributeReq(ConceptProto.AttributeType.Attribute.Req.newBuilder()
-                                                      .setValue(RequestBuilder.Concept.attributeValue(value))).build();
+                                                      .setValue(RequestBuilder.ConceptMessage.attributeValue(value))).build();
 
         ConceptProto.AttributeType.Attribute.Res response = runMethod(method).getAttributeTypeAttributeRes();
         switch (response.getResCase()) {
             case NULL:
                 return null;
             case ATTRIBUTE:
-                return RemoteConcept.of(response.getAttribute(), tx()).asAttribute();
+                return Concept.of(response.getAttribute(), tx()).asAttribute();
             default:
                 throw GraknClientException.unreachableStatement("Unexpected response " + response);
         }
     }
 
     @Nullable
-    @Override
     public final AttributeType.DataType<D> dataType() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setAttributeTypeDataTypeReq(ConceptProto.AttributeType.DataType.Req.getDefaultInstance()).build();
@@ -84,14 +75,13 @@ public final AttributeType.DataType<D> dataType() {
             case NULL:
                 return null;
             case DATATYPE:
-                return (AttributeType.DataType<D>) RequestBuilder.Concept.dataType(response.getDataType());
+                return (AttributeType.DataType<D>) RequestBuilder.ConceptMessage.dataType(response.getDataType());
             default:
                 throw GraknClientException.unreachableStatement("Unexpected response " + response);
         }
     }
 
     @Nullable
-    @Override
     public final String regex() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setAttributeTypeGetRegexReq(ConceptProto.AttributeType.GetRegex.Req.getDefaultInstance()).build();
@@ -100,8 +90,7 @@ public final String regex() {
         return regex.isEmpty() ? null : regex;
     }
 
-    @Override
-    public final AttributeType<D> regex(String regex) {
+    public final AttributeType regex(String regex) {
         if (regex == null) regex = "";
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setAttributeTypeSetRegexReq(ConceptProto.AttributeType.SetRegex.Req.newBuilder()
@@ -112,7 +101,7 @@ public final AttributeType<D> regex(String regex) {
     }
 
     @Override
-    final AttributeType<D> asCurrentBaseType(Concept other) {
+    final AttributeType asCurrentBaseType(Concept other) {
         return other.asAttributeType();
     }
 
@@ -125,4 +114,75 @@ final boolean equalsCurrentBaseType(Concept other) {
     protected final Attribute<D> asInstance(Concept concept) {
         return concept.asAttribute();
     }
+
+    @SuppressWarnings("unchecked")
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public AttributeType asAttributeType() {
+        return this;
+    }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public boolean isAttributeType() {
+        return true;
+    }
+
+
+    /**
+     * A class used to hold the supported data types of resources and any other concepts.
+     * This is used tp constrain value data types to only those we explicitly support.
+     *
+     * @param <D> The data type.
+     */
+    public static class DataType<D> {
+        public static final AttributeType.DataType<Boolean> BOOLEAN = new DataType<>(Boolean.class);
+        public static final AttributeType.DataType<LocalDateTime> DATE = new AttributeType.DataType<>(LocalDateTime.class);
+        public static final AttributeType.DataType<Double> DOUBLE = new AttributeType.DataType<>(Double.class);
+        public static final AttributeType.DataType<Float> FLOAT = new AttributeType.DataType<>(Float.class);
+        public static final AttributeType.DataType<Integer> INTEGER = new AttributeType.DataType<>(Integer.class);
+        public static final AttributeType.DataType<Long> LONG = new AttributeType.DataType<>(Long.class);
+        public static final AttributeType.DataType<String> STRING = new AttributeType.DataType<>(String.class);
+
+        private final Class<D> dataClass;
+
+        private DataType(Class<D> dataClass) {
+            this.dataClass = dataClass;
+        }
+
+        @CheckReturnValue
+        public Class<D> dataClass() {
+            return dataClass;
+        }
+
+        @CheckReturnValue
+        public String name() {
+            return dataClass.getName();
+        }
+
+        @Override
+        public String toString() {
+            return name();
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+
+            AttributeType.DataType<?> that = (AttributeType.DataType<?>) o;
+
+            return (this.dataClass().equals(that.dataClass()));
+        }
+
+        @Override
+        public int hashCode() {
+            int h = 1;
+            h *= 1000003;
+            h ^=  dataClass.hashCode();
+            return h;
+        }
+    }
 }
diff --git a/concept/Concept.java b/concept/Concept.java
new file mode 100644
index 0000000000..e97df2a3e3
--- /dev/null
+++ b/concept/Concept.java
@@ -0,0 +1,366 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package grakn.client.concept;
+
+import grakn.client.GraknClient;
+import grakn.protocol.session.ConceptProto;
+
+import javax.annotation.CheckReturnValue;
+import java.util.function.Function;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/**
+ * Client implementation of Concept
+ *
+ * @param <SomeConcept> represents the actual class of object to downcast to
+ */
+public abstract class Concept<SomeConcept extends Concept> {
+
+    private final GraknClient.Transaction tx;
+    private final ConceptId id;
+
+    Concept(GraknClient.Transaction tx, ConceptId id) {
+        if (tx == null) {
+            throw new NullPointerException("Null tx");
+        }
+        this.tx = tx;
+        if (id == null) {
+            throw new NullPointerException("Null id");
+        }
+        this.id = id;
+    }
+
+    public static Concept of(ConceptProto.Concept concept, GraknClient.Transaction tx) {
+        ConceptId id = ConceptId.of(concept.getId());
+
+        switch (concept.getBaseType()) {
+            case ENTITY:
+                return new Entity(tx, id);
+            case RELATION:
+                return new Relation(tx, id);
+            case ATTRIBUTE:
+                return new Attribute(tx, id);
+            case ENTITY_TYPE:
+                return new EntityType(tx, id);
+            case RELATION_TYPE:
+                return new RelationType(tx, id);
+            case ATTRIBUTE_TYPE:
+                return new AttributeType(tx, id);
+            case ROLE:
+                return new Role(tx, id);
+            case RULE:
+                return new Rule(tx, id);
+            case META_TYPE:
+                return new MetaType(tx, id);
+            default:
+            case UNRECOGNIZED:
+                throw new IllegalArgumentException("Unrecognised " + concept);
+        }
+    }
+
+
+    public ConceptId id() {
+        return id;
+    }
+
+    public final void delete() {
+        ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
+                .setConceptDeleteReq(ConceptProto.Concept.Delete.Req.getDefaultInstance())
+                .build();
+
+        runMethod(method);
+    }
+
+    public final boolean isDeleted() {
+        return tx().getConcept(id()) == null;
+    }
+
+    /**
+     * Return as a SchemaConcept if the Concept is a SchemaConcept.
+     *
+     * @return A SchemaConcept if the Concept is a SchemaConcept
+     */
+    @CheckReturnValue
+    public SchemaConcept asSchemaConcept() {
+        throw GraknConceptException.invalidCasting(this, SchemaConcept.class);
+    }
+
+    /**
+     * Return as a Type if the Concept is a Type.
+     *
+     * @return A Type if the Concept is a Type
+     */
+    @CheckReturnValue
+    public Type asType() {
+        throw GraknConceptException.invalidCasting(this, Type.class);
+    }
+
+    /**
+     * Return as an Thing if the Concept is an Thing.
+     *
+     * @return An Thing if the Concept is an Thing
+     */
+    @CheckReturnValue
+    public Thing asThing() {
+        throw GraknConceptException.invalidCasting(this, Thing.class);
+    }
+
+    /**
+     * Return as an EntityType if the Concept is an EntityType.
+     *
+     * @return A EntityType if the Concept is an EntityType
+     */
+    @CheckReturnValue
+    public EntityType asEntityType() {
+        throw GraknConceptException.invalidCasting(this, EntityType.class);
+    }
+
+    /**
+     * Return as a Role if the Concept is a Role.
+     *
+     * @return A Role if the Concept is a Role
+     */
+    @CheckReturnValue
+    public Role asRole() {
+        throw GraknConceptException.invalidCasting(this, Role.class);
+    }
+
+    /**
+     * Return as a RelationType if the Concept is a RelationType.
+     *
+     * @return A RelationType if the Concept is a RelationType
+     */
+    @CheckReturnValue
+    public RelationType asRelationType() {
+        throw GraknConceptException.invalidCasting(this, RelationType.class);
+    }
+
+    /**
+     * Return as a AttributeType if the Concept is a AttributeType
+     *
+     * @return A AttributeType if the Concept is a AttributeType
+     */
+    @CheckReturnValue
+    public <D> AttributeType<D> asAttributeType() {
+        throw GraknConceptException.invalidCasting(this, AttributeType.class);
+    }
+
+    /**
+     * Return as a Rule if the Concept is a Rule.
+     *
+     * @return A Rule if the Concept is a Rule
+     */
+    @CheckReturnValue
+    public Rule asRule() {
+        throw GraknConceptException.invalidCasting(this, Rule.class);
+    }
+
+    /**
+     * Return as an Entity, if the Concept is an Entity Thing.
+     *
+     * @return An Entity if the Concept is a Thing
+     */
+    @CheckReturnValue
+    public Entity asEntity() {
+        throw GraknConceptException.invalidCasting(this, Entity.class);
+    }
+
+    /**
+     * Return as a Relation if the Concept is a Relation Thing.
+     *
+     * @return A Relation  if the Concept is a Relation
+     */
+    @CheckReturnValue
+    public Relation asRelation() {
+        throw GraknConceptException.invalidCasting(this, Relation.class);
+    }
+
+    /**
+     * Return as a Attribute  if the Concept is a Attribute Thing.
+     *
+     * @return A Attribute if the Concept is a Attribute
+     */
+    @CheckReturnValue
+    public <D> Attribute<D> asAttribute() {
+        throw GraknConceptException.invalidCasting(this, Attribute.class);
+    }
+
+    /**
+     * Determine if the Concept is a SchemaConcept
+     *
+     * @return true if theConcept concept is a SchemaConcept
+     */
+    @CheckReturnValue
+    public boolean isSchemaConcept() {
+        return false;
+    }
+
+    /**
+     * Determine if the Concept is a Type.
+     *
+     * @return true if theConcept concept is a Type
+     */
+    @CheckReturnValue
+    public boolean isType() {
+        return false;
+    }
+
+    /**
+     * Determine if the Concept is an Thing.
+     *
+     * @return true if the Concept is an Thing
+     */
+    @CheckReturnValue
+    public boolean isThing() {
+        return false;
+    }
+
+    /**
+     * Determine if the Concept is an EntityType.
+     *
+     * @return true if the Concept is an EntityType.
+     */
+    @CheckReturnValue
+    public boolean isEntityType() {
+        return false;
+    }
+
+    /**
+     * Determine if the Concept is a Role.
+     *
+     * @return true if the Concept is a Role
+     */
+    @CheckReturnValue
+    public boolean isRole() {
+        return false;
+    }
+
+    /**
+     * Determine if the Concept is a RelationType.
+     *
+     * @return true if the Concept is a RelationType
+     */
+    @CheckReturnValue
+    public boolean isRelationType() {
+        return false;
+    }
+
+    /**
+     * Determine if the Concept is a AttributeType.
+     *
+     * @return true if theConcept concept is a AttributeType
+     */
+    @CheckReturnValue
+    public boolean isAttributeType() {
+        return false;
+    }
+
+    /**
+     * Determine if the Concept is a Rule.
+     *
+     * @return true if the Concept is a Rule
+     */
+    @CheckReturnValue
+    public boolean isRule() {
+        return false;
+    }
+
+    /**
+     * Determine if the Concept is an Entity.
+     *
+     * @return true if the Concept is a Entity
+     */
+    @CheckReturnValue
+    public boolean isEntity() {
+        return false;
+    }
+
+    /**
+     * Determine if the Concept is a Relation.
+     *
+     * @return true if the Concept is a Relation
+     */
+    @CheckReturnValue
+    public boolean isRelation() {
+        return false;
+    }
+
+    /**
+     * Determine if the Concept is a Attribute.
+     *
+     * @return true if the Concept is a Attribute
+     */
+    @CheckReturnValue
+    public boolean isAttribute() {
+        return false;
+    }
+
+
+    @Override
+    public String toString() {
+        return this.getClass().getSimpleName() + "{tx=" + tx + ", id=" + id + "}";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Concept<?> that = (Concept<?>) o;
+
+        return (tx.equals(that.tx())) &&
+                id.equals(that.id());
+    }
+
+    @Override
+    public int hashCode() {
+        int h = 1;
+        h *= 1000003;
+        h ^= tx.hashCode();
+        h *= 1000003;
+        h ^= id.hashCode();
+        return h;
+    }
+
+    GraknClient.Transaction tx() {
+        return tx;
+    }
+    abstract SomeConcept asCurrentBaseType(Concept other);
+
+    final Stream<? extends Concept> conceptStream
+            (int iteratorId, Function<ConceptProto.Method.Iter.Res, ConceptProto.Concept> conceptGetter) {
+
+        Iterable<? extends Concept> iterable = () -> tx().iterator(
+                iteratorId, res -> of(conceptGetter.apply(res.getConceptMethodIterRes()), tx())
+        );
+
+        return StreamSupport.stream(iterable.spliterator(), false);
+    }
+
+    protected final ConceptProto.Method.Res runMethod(ConceptProto.Method.Req method) {
+        return runMethod(id(), method);
+    }
+
+    protected final ConceptProto.Method.Res runMethod(ConceptId id, ConceptProto.Method.Req method) {
+        return tx().runConceptMethod(id, method).getConceptMethodRes().getResponse();
+    }
+
+}
diff --git a/concept/ConceptId.java b/concept/ConceptId.java
new file mode 100644
index 0000000000..77883b6f14
--- /dev/null
+++ b/concept/ConceptId.java
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package grakn.client.concept;
+
+import javax.annotation.CheckReturnValue;
+import java.io.Serializable;
+
+/**
+ * A class which represents an id of any Concept.
+ * Also contains a static method for producing concept IDs from Strings.
+ */
+public class ConceptId implements Comparable<ConceptId>, Serializable {
+
+    private static final long serialVersionUID = -1723590529071614152L;
+    private final String value;
+
+    /**
+     * A non-argument constructor for ConceptID, for serialisation of OLAP queries dependencies
+     */
+    ConceptId() {
+        this.value = null;
+    }
+
+    /**
+     * The default constructor for ConceptID, which requires String value provided
+     *
+     * @param value String representation of the Concept ID
+     */
+    ConceptId(String value) {
+        if (value == null) throw new NullPointerException("Provided ConceptId is NULL");
+
+        this.value = value;
+    }
+
+    /**
+     * @param value The string which potentially represents a Concept
+     * @return The matching concept ID
+     */
+    @CheckReturnValue
+    public static ConceptId of(String value) {
+        return new ConceptId(value);
+    }
+
+    /**
+     * @return Used for indexing purposes and for graql traversals
+     */
+    @CheckReturnValue
+    public String getValue() {
+        return value;
+    }
+
+    @Override
+    public int compareTo(ConceptId o) {
+        return getValue().compareTo(o.getValue());
+    }
+
+    @Override
+    public final String toString() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (o == null || this.getClass() != o.getClass()) return false;
+
+        ConceptId that = (ConceptId) o;
+        return (this.value.equals(that.getValue()));
+    }
+
+    @Override
+    public int hashCode() {
+        int result = 31 * this.value.hashCode();
+        return result;
+    }
+}
diff --git a/concept/RemoteEntity.java b/concept/Entity.java
similarity index 73%
rename from concept/RemoteEntity.java
rename to concept/Entity.java
index 9630ceedc2..791453d6ea 100644
--- a/concept/RemoteEntity.java
+++ b/concept/Entity.java
@@ -20,22 +20,30 @@
 package grakn.client.concept;
 
 import grakn.client.GraknClient;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.thing.Entity;
-import grakn.core.concept.type.EntityType;
+
+import javax.annotation.CheckReturnValue;
 
 /**
  * Client implementation of Entity
  */
-public class RemoteEntity extends RemoteThing<Entity, EntityType> implements Entity {
+public class Entity extends Thing<Entity, EntityType> {
 
-    RemoteEntity(GraknClient.Transaction tx, ConceptId id) {
+    Entity(GraknClient.Transaction tx, ConceptId id) {
         super(tx, id);
     }
 
-    static RemoteEntity construct(GraknClient.Transaction tx, ConceptId id) {
-        return new RemoteEntity(tx, id);
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public Entity asEntity() {
+        return this;
+    }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public boolean isEntity() {
+        return true;
     }
 
     @Override
diff --git a/concept/RemoteEntityType.java b/concept/EntityType.java
similarity index 76%
rename from concept/RemoteEntityType.java
rename to concept/EntityType.java
index 3b0eaa8a9d..b60a7e0405 100644
--- a/concept/RemoteEntityType.java
+++ b/concept/EntityType.java
@@ -20,33 +20,26 @@
 package grakn.client.concept;
 
 import grakn.client.GraknClient;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.thing.Entity;
-import grakn.core.concept.type.EntityType;
 import grakn.protocol.session.ConceptProto;
 
+import javax.annotation.CheckReturnValue;
+
 /**
  * Client implementation of a MetaType, a special type of Type
  * TODO: This class is not defined in Concept API, and at server side implementation.
  * TODO: we should remove this class, or implement properly on server side.
  */
-public class RemoteEntityType extends RemoteType<EntityType, Entity> implements EntityType {
+public class EntityType extends Type<EntityType, Entity> {
 
-    RemoteEntityType(GraknClient.Transaction tx, ConceptId id) {
+    public EntityType(GraknClient.Transaction tx, ConceptId id) {
         super(tx, id);
     }
 
-    static RemoteEntityType construct(GraknClient.Transaction tx, ConceptId id) {
-        return new RemoteEntityType(tx, id);
-    }
-
-    @Override
     public final Entity create() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setEntityTypeCreateReq(ConceptProto.EntityType.Create.Req.getDefaultInstance()).build();
 
-        Concept concept = RemoteConcept.of(runMethod(method).getEntityTypeCreateRes().getEntity(), tx());
+        Concept concept = Concept.of(runMethod(method).getEntityTypeCreateRes().getEntity(), tx());
         return asInstance(concept);
     }
 
@@ -64,4 +57,18 @@ final boolean equalsCurrentBaseType(Concept other) {
     protected final Entity asInstance(Concept concept) {
         return concept.asEntity();
     }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public EntityType asEntityType() {
+        return this;
+    }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public boolean isEntityType() {
+        return true;
+    }
 }
diff --git a/concept/GraknConceptException.java b/concept/GraknConceptException.java
new file mode 100644
index 0000000000..d1ffe20666
--- /dev/null
+++ b/concept/GraknConceptException.java
@@ -0,0 +1,48 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package grakn.client.concept;
+
+public class GraknConceptException extends RuntimeException {
+    final static String INVALID_OBJECT_TYPE = "The concept [%s] is not of type [%s]";
+    final static String VARIABLE_DOES_NOT_EXIST = "the variable [%s] does not exist";
+
+    private GraknConceptException(String error) {
+        super(error);
+    }
+
+    public String getName() {
+        return this.getClass().getName();
+    }
+
+    public static GraknConceptException create(String error) {
+        return new GraknConceptException(error);
+    }
+
+    /**
+     * Thrown when casting Grakn concepts/answers incorrectly.
+     */
+    public static GraknConceptException invalidCasting(Object concept, Class type) {
+        return GraknConceptException.create(String.format(INVALID_OBJECT_TYPE,concept, type));
+    }
+
+    public static GraknConceptException variableDoesNotExist(String var) {
+        return new GraknConceptException(String.format(VARIABLE_DOES_NOT_EXIST, var));
+    }
+}
diff --git a/concept/Label.java b/concept/Label.java
new file mode 100644
index 0000000000..560c885281
--- /dev/null
+++ b/concept/Label.java
@@ -0,0 +1,96 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package grakn.client.concept;
+
+import javax.annotation.CheckReturnValue;
+import java.io.Serializable;
+import java.util.function.Function;
+
+/**
+ * A Label
+ * A class which represents the unique label of any SchemaConcept
+ * Also contains a static method for producing Labels from Strings.
+ */
+public class Label implements Comparable<Label>, Serializable {
+    private static final long serialVersionUID = 2051578406740868932L;
+
+    private final String value;
+
+    private Label(String value) {
+        if (value == null) {
+            throw new NullPointerException("Null value");
+        }
+        this.value = value;
+    }
+
+    /**
+     * @param value The string which potentially represents a Type
+     * @return The matching Type Label
+     */
+    @CheckReturnValue
+    public static Label of(String value) {
+        return new Label(value);
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    /**
+     * Rename a Label (does not modify the original Label)
+     *
+     * @param mapper a function to apply to the underlying type label
+     * @return the new type label
+     */
+    @CheckReturnValue
+    public Label map(Function<String, String> mapper) {
+        return Label.of(mapper.apply(getValue()));
+    }
+
+    @Override
+    public int compareTo(Label o) {
+        return getValue().compareTo(o.getValue());
+    }
+
+    @Override
+    public final String toString() {
+        return getValue();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (o instanceof Label) {
+            Label that = (Label) o;
+            return (this.value.equals(that.getValue()));
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        int h = 1;
+        h *= 1000003;
+        h ^= this.value.hashCode();
+        return h;
+    }
+}
diff --git a/concept/RemoteMetaType.java b/concept/MetaType.java
similarity index 75%
rename from concept/RemoteMetaType.java
rename to concept/MetaType.java
index e7431d7e56..d743f3e019 100644
--- a/concept/RemoteMetaType.java
+++ b/concept/MetaType.java
@@ -20,24 +20,16 @@
 package grakn.client.concept;
 
 import grakn.client.GraknClient;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.thing.Thing;
-import grakn.core.concept.type.Type;
 
 /**
  * Client implementation of Type
  */
-public class RemoteMetaType extends RemoteType<Type, Thing> {
+public class MetaType extends Type<Type, Thing> {
 
-    RemoteMetaType(GraknClient.Transaction tx, ConceptId id) {
+    MetaType(GraknClient.Transaction tx, ConceptId id) {
         super(tx, id);
     }
 
-    static RemoteMetaType construct(GraknClient.Transaction tx, ConceptId id) {
-        return new RemoteMetaType(tx, id);
-    }
-
     @Override
     final Type asCurrentBaseType(Concept other) {
         return other.asType();
diff --git a/concept/RemoteRelation.java b/concept/Relation.java
similarity index 71%
rename from concept/RemoteRelation.java
rename to concept/Relation.java
index 4b13e9543a..df07a12e13 100644
--- a/concept/RemoteRelation.java
+++ b/concept/Relation.java
@@ -21,14 +21,9 @@
 
 import grakn.client.GraknClient;
 import grakn.client.rpc.RequestBuilder;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.thing.Relation;
-import grakn.core.concept.thing.Thing;
-import grakn.core.concept.type.RelationType;
-import grakn.core.concept.type.Role;
 import grakn.protocol.session.ConceptProto;
 
+import javax.annotation.CheckReturnValue;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
@@ -40,17 +35,12 @@
 /**
  * Client implementation of Relation
  */
-public class RemoteRelation extends RemoteThing<Relation, RelationType> implements Relation {
+public class Relation extends Thing<Relation, RelationType> {
 
-    RemoteRelation(GraknClient.Transaction tx, ConceptId id) {
+    Relation(GraknClient.Transaction tx, ConceptId id) {
         super(tx, id);
     }
 
-    static RemoteRelation construct(GraknClient.Transaction tx, ConceptId id) {
-        return new RemoteRelation(tx, id);
-    }
-
-    @Override // TODO: Weird. Why is this not a stream, while other collections are returned as stream
     public final Map<Role, Set<Thing>> rolePlayersMap() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setRelationRolePlayersMapReq(ConceptProto.Relation.RolePlayersMap.Req.getDefaultInstance()).build();
@@ -62,8 +52,8 @@ public final Map<Role, Set<Thing>> rolePlayersMap() {
 
         Map<Role, Set<Thing>> rolePlayerMap = new HashMap<>();
         for (ConceptProto.Relation.RolePlayersMap.Iter.Res rolePlayer : rolePlayers) {
-            Role role = RemoteConcept.of(rolePlayer.getRole(), tx()).asRole();
-            Thing player = RemoteConcept.of(rolePlayer.getPlayer(), tx()).asThing();
+            Role role = Concept.of(rolePlayer.getRole(), tx()).asRole();
+            Thing player = Concept.of(rolePlayer.getPlayer(), tx()).asThing();
             if (rolePlayerMap.containsKey(role)) {
                 rolePlayerMap.get(role).add(player);
             } else {
@@ -74,44 +64,54 @@ public final Map<Role, Set<Thing>> rolePlayersMap() {
         return rolePlayerMap;
     }
 
-    @Override
     public final Stream<Thing> rolePlayers(Role... roles) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setRelationRolePlayersReq(ConceptProto.Relation.RolePlayers.Req.newBuilder()
-                                                   .addAllRoles(RequestBuilder.Concept.concepts(Arrays.asList(roles)))).build();
+                        .addAllRoles(RequestBuilder.ConceptMessage.concepts(Arrays.asList(roles)))).build();
 
         int iteratorId = runMethod(method).getRelationRolePlayersIter().getId();
         return conceptStream(iteratorId, res -> res.getRelationRolePlayersIterRes().getThing()).map(Concept::asThing);
     }
 
-    @Override
     public final Relation assign(Role role, Thing player) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setRelationAssignReq(ConceptProto.Relation.Assign.Req.newBuilder()
-                                              .setRole(RequestBuilder.Concept.concept(role))
-                                              .setPlayer(RequestBuilder.Concept.concept(player))).build();
+                        .setRole(RequestBuilder.ConceptMessage.from(role))
+                        .setPlayer(RequestBuilder.ConceptMessage.from(player))).build();
 
         runMethod(method);
         return asCurrentBaseType(this);
     }
 
-    @Override
     public final void unassign(Role role, Thing player) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setRelationUnassignReq(ConceptProto.Relation.Unassign.Req.newBuilder()
-                                                .setRole(RequestBuilder.Concept.concept(role))
-                                                .setPlayer(RequestBuilder.Concept.concept(player))).build();
+                        .setRole(RequestBuilder.ConceptMessage.from(role))
+                        .setPlayer(RequestBuilder.ConceptMessage.from(player))).build();
 
         runMethod(method);
     }
 
-    @Override
     final RelationType asCurrentType(Concept concept) {
         return concept.asRelationType();
     }
 
-    @Override
     final Relation asCurrentBaseType(Concept other) {
         return other.asRelation();
     }
+
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public Relation asRelation() {
+        return this;
+    }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public boolean isRelation() {
+        return true;
+    }
 }
diff --git a/concept/RemoteRelationType.java b/concept/RelationType.java
similarity index 79%
rename from concept/RemoteRelationType.java
rename to concept/RelationType.java
index fb64548e29..ce6b427b77 100644
--- a/concept/RemoteRelationType.java
+++ b/concept/RelationType.java
@@ -21,39 +21,29 @@
 
 import grakn.client.GraknClient;
 import grakn.client.rpc.RequestBuilder;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.thing.Relation;
-import grakn.core.concept.type.RelationType;
-import grakn.core.concept.type.Role;
 import grakn.protocol.session.ConceptProto;
 
+import javax.annotation.CheckReturnValue;
 import java.util.stream.Stream;
 
 /**
  * Client implementation of RelationType
  */
-public class RemoteRelationType extends RemoteType<RelationType, Relation> implements RelationType {
+public class RelationType extends Type<RelationType, Relation> {
 
-    RemoteRelationType(GraknClient.Transaction tx, ConceptId id) {
+    RelationType(GraknClient.Transaction tx, ConceptId id) {
         super(tx, id);
     }
 
-    static RemoteRelationType construct(GraknClient.Transaction tx, ConceptId id) {
-        return new RemoteRelationType(tx, id);
-    }
-
-    @Override
     public final Relation create() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setRelationTypeCreateReq(ConceptProto.RelationType.Create.Req.getDefaultInstance()).build();
 
-        Concept concept = RemoteConcept.of(runMethod(method).getRelationTypeCreateRes().getRelation(), tx());
+        Concept concept = Concept.of(runMethod(method).getRelationTypeCreateRes().getRelation(), tx());
 
         return asInstance(concept);
     }
 
-    @Override
     public final Stream<Role> roles() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setRelationTypeRolesReq(ConceptProto.RelationType.Roles.Req.getDefaultInstance()).build();
@@ -62,21 +52,19 @@ public final Stream<Role> roles() {
         return conceptStream(iteratorId, res -> res.getRelationTypeRolesIterRes().getRole()).map(Concept::asRole);
     }
 
-    @Override
     public final RelationType relates(Role role) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setRelationTypeRelatesReq(ConceptProto.RelationType.Relates.Req.newBuilder()
-                                                   .setRole(RequestBuilder.Concept.concept(role))).build();
+                                                   .setRole(RequestBuilder.ConceptMessage.from(role))).build();
 
         runMethod(method);
         return asCurrentBaseType(this);
     }
 
-    @Override
     public final RelationType unrelate(Role role) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setRelationTypeUnrelateReq(ConceptProto.RelationType.Unrelate.Req.newBuilder()
-                                                    .setRole(RequestBuilder.Concept.concept(role))).build();
+                                                    .setRole(RequestBuilder.ConceptMessage.from(role))).build();
 
         runMethod(method);
         return asCurrentBaseType(this);
@@ -96,4 +84,18 @@ final boolean equalsCurrentBaseType(Concept other) {
     protected final Relation asInstance(Concept concept) {
         return concept.asRelation();
     }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public RelationType asRelationType() {
+        return this;
+    }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public boolean isRelationType() {
+        return true;
+    }
 }
diff --git a/concept/RemoteConcept.java b/concept/RemoteConcept.java
deleted file mode 100644
index aa51824c6d..0000000000
--- a/concept/RemoteConcept.java
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package grakn.client.concept;
-
-import grakn.client.GraknClient;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.protocol.session.ConceptProto;
-
-import java.util.function.Function;
-import java.util.stream.Stream;
-import java.util.stream.StreamSupport;
-
-/**
- * Client implementation of Concept
- *
- * @param <SomeConcept> represents the actual class of object to downcast to
- */
-public abstract class RemoteConcept<SomeConcept extends Concept> implements Concept {
-
-    private final GraknClient.Transaction tx;
-    private final ConceptId id;
-
-    RemoteConcept(GraknClient.Transaction tx, ConceptId id) {
-        if (tx == null) {
-            throw new NullPointerException("Null tx");
-        }
-        this.tx = tx;
-        if (id == null) {
-            throw new NullPointerException("Null id");
-        }
-        this.id = id;
-    }
-
-    public static Concept of(ConceptProto.Concept concept, GraknClient.Transaction tx) {
-        ConceptId id = ConceptId.of(concept.getId());
-
-        switch (concept.getBaseType()) {
-            case ENTITY:
-                return RemoteEntity.construct(tx, id);
-            case RELATION:
-                return RemoteRelation.construct(tx, id);
-            case ATTRIBUTE:
-                return RemoteAttribute.construct(tx, id);
-            case ENTITY_TYPE:
-                return RemoteEntityType.construct(tx, id);
-            case RELATION_TYPE:
-                return RemoteRelationType.construct(tx, id);
-            case ATTRIBUTE_TYPE:
-                return RemoteAttributeType.construct(tx, id);
-            case ROLE:
-                return RemoteRole.construct(tx, id);
-            case RULE:
-                return RemoteRule.construct(tx, id);
-            case META_TYPE:
-                return RemoteMetaType.construct(tx, id);
-            default:
-            case UNRECOGNIZED:
-                throw new IllegalArgumentException("Unrecognised " + concept);
-        }
-    }
-
-    GraknClient.Transaction tx() {
-        return tx;
-    }
-
-    public ConceptId id() {
-        return id;
-    }
-
-    @Override
-    public final void delete() {
-        ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
-                .setConceptDeleteReq(ConceptProto.Concept.Delete.Req.getDefaultInstance())
-                .build();
-
-        runMethod(method);
-    }
-
-    @Override
-    public final boolean isDeleted() {
-        return tx().getConcept(id()) == null;
-    }
-
-    abstract SomeConcept asCurrentBaseType(Concept other);
-
-    protected final Stream<? extends Concept> conceptStream
-            (int iteratorId, Function<ConceptProto.Method.Iter.Res, ConceptProto.Concept> conceptGetter) {
-
-        Iterable<? extends Concept> iterable = () -> tx().iterator(
-                iteratorId, res -> of(conceptGetter.apply(res.getConceptMethodIterRes()), tx())
-        );
-
-        return StreamSupport.stream(iterable.spliterator(), false);
-    }
-
-    protected final ConceptProto.Method.Res runMethod(ConceptProto.Method.Req method) {
-        return runMethod(id(), method);
-    }
-
-    protected final ConceptProto.Method.Res runMethod(ConceptId id, ConceptProto.Method.Req method) {
-        return tx().runConceptMethod(id, method).getConceptMethodRes().getResponse();
-    }
-
-    @Override
-    public String toString() {
-        return this.getClass().getSimpleName() + "{tx=" + tx + ", id=" + id + "}";
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-
-        RemoteConcept<?> that = (RemoteConcept<?>) o;
-
-        return (tx.equals(that.tx())) &&
-                id.equals(that.id());
-    }
-
-    @Override
-    public int hashCode() {
-        int h = 1;
-        h *= 1000003;
-        h ^= tx.hashCode();
-        h *= 1000003;
-        h ^= id.hashCode();
-        return h;
-    }
-}
diff --git a/concept/RemoteRole.java b/concept/Role.java
similarity index 82%
rename from concept/RemoteRole.java
rename to concept/Role.java
index b06a3b8420..b6f2bceb8b 100644
--- a/concept/RemoteRole.java
+++ b/concept/Role.java
@@ -20,29 +20,20 @@
 package grakn.client.concept;
 
 import grakn.client.GraknClient;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.type.RelationType;
-import grakn.core.concept.type.Role;
-import grakn.core.concept.type.Type;
 import grakn.protocol.session.ConceptProto;
 
+import javax.annotation.CheckReturnValue;
 import java.util.stream.Stream;
 
 /**
  * Client implementation of Role
  */
-public class RemoteRole extends RemoteSchemaConcept<Role> implements Role {
+public class Role extends SchemaConcept<Role> {
 
-    RemoteRole(GraknClient.Transaction tx, ConceptId id) {
+    Role(GraknClient.Transaction tx, ConceptId id) {
         super(tx, id);
     }
 
-    static RemoteRole construct(GraknClient.Transaction tx, ConceptId id) {
-        return new RemoteRole(tx, id);
-    }
-
-    @Override
     public final Stream<RelationType> relations() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setRoleRelationsReq(ConceptProto.Role.Relations.Req.getDefaultInstance()).build();
@@ -50,7 +41,6 @@ public final Stream<RelationType> relations() {
         return conceptStream(iteratorId, res -> res.getRoleRelationsIterRes().getRelationType()).map(Concept::asRelationType);
     }
 
-    @Override
     public final Stream<Type> players() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setRolePlayersReq(ConceptProto.Role.Players.Req.getDefaultInstance()).build();
@@ -67,4 +57,18 @@ final Role asCurrentBaseType(Concept other) {
     final boolean equalsCurrentBaseType(Concept other) {
         return other.isRole();
     }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public Role asRole() {
+        return this;
+    }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public boolean isRole() {
+        return true;
+    }
 }
diff --git a/concept/RemoteRule.java b/concept/Rule.java
similarity index 88%
rename from concept/RemoteRule.java
rename to concept/Rule.java
index c61a0c2c04..4733d3a040 100644
--- a/concept/RemoteRule.java
+++ b/concept/Rule.java
@@ -21,32 +21,24 @@
 
 import grakn.client.GraknClient;
 import grakn.client.exception.GraknClientException;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.type.Rule;
-import grakn.core.concept.type.Type;
 import grakn.protocol.session.ConceptProto;
 import graql.lang.Graql;
 import graql.lang.pattern.Pattern;
 
+import javax.annotation.CheckReturnValue;
 import javax.annotation.Nullable;
 import java.util.stream.Stream;
 
 /**
  * Client implementation of Rule
  */
-public class RemoteRule extends RemoteSchemaConcept<Rule> implements Rule {
+public class Rule extends SchemaConcept<Rule> {
 
-    RemoteRule(GraknClient.Transaction tx, ConceptId id) {
+    Rule(GraknClient.Transaction tx, ConceptId id) {
         super(tx, id);
     }
 
-    static RemoteRule construct(GraknClient.Transaction tx, ConceptId id) {
-        return new RemoteRule(tx, id);
-    }
-
     @Nullable
-    @Override
     @SuppressWarnings("Duplicates") // response.getResCase() does not return the same type
     public final Pattern when() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
@@ -64,7 +56,6 @@ public final Pattern when() {
     }
 
     @Nullable
-    @Override
     @SuppressWarnings("Duplicates") // response.getResCase() does not return the same type
     public final Pattern then() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
@@ -81,22 +72,18 @@ public final Pattern then() {
         }
     }
 
-    @Override
     public final Stream<Type> whenTypes() {
         throw new UnsupportedOperationException(); // TODO: remove from API
     }
 
-    @Override
     public Stream<Type> whenPositiveTypes() {
         throw new UnsupportedOperationException(); // TODO: remove from API
     }
 
-    @Override
     public Stream<Type> whenNegativeTypes() {
         throw new UnsupportedOperationException(); // TODO: remove from API
     }
 
-    @Override
     public final Stream<Type> thenTypes() {
         throw new UnsupportedOperationException(); // TODO: remove from API
     }
@@ -110,4 +97,18 @@ final Rule asCurrentBaseType(Concept other) {
     final boolean equalsCurrentBaseType(Concept other) {
         return other.isRule();
     }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public Rule asRule() {
+        return this;
+    }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public boolean isRule() {
+        return true;
+    }
 }
diff --git a/concept/RemoteSchemaConcept.java b/concept/SchemaConcept.java
similarity index 79%
rename from concept/RemoteSchemaConcept.java
rename to concept/SchemaConcept.java
index 996353bec8..150317bf32 100644
--- a/concept/RemoteSchemaConcept.java
+++ b/concept/SchemaConcept.java
@@ -22,14 +22,9 @@
 import grakn.client.GraknClient;
 import grakn.client.exception.GraknClientException;
 import grakn.client.rpc.RequestBuilder;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.Label;
-import grakn.core.concept.LabelId;
-import grakn.core.concept.type.Rule;
-import grakn.core.concept.type.SchemaConcept;
 import grakn.protocol.session.ConceptProto;
 
+import javax.annotation.CheckReturnValue;
 import javax.annotation.Nullable;
 import java.util.stream.Stream;
 
@@ -38,22 +33,21 @@
  *
  * @param <SomeSchemaConcept> The exact type of this class
  */
-abstract class RemoteSchemaConcept<SomeSchemaConcept extends SchemaConcept> extends RemoteConcept<SomeSchemaConcept> implements SchemaConcept {
+public abstract class SchemaConcept<SomeSchemaConcept extends SchemaConcept> extends Concept<SomeSchemaConcept> {
 
-    RemoteSchemaConcept(GraknClient.Transaction tx, ConceptId id) {
+    SchemaConcept(GraknClient.Transaction tx, ConceptId id) {
         super(tx, id);
     }
 
     public final SomeSchemaConcept sup(SomeSchemaConcept type) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setSchemaConceptSetSupReq(ConceptProto.SchemaConcept.SetSup.Req.newBuilder()
-                                                   .setSchemaConcept(RequestBuilder.Concept.concept(type))).build();
+                                                   .setSchemaConcept(RequestBuilder.ConceptMessage.from(type))).build();
 
         runMethod(method);
         return asCurrentBaseType(this);
     }
 
-    @Override
     public final Label label() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setSchemaConceptGetLabelReq(ConceptProto.SchemaConcept.GetLabel.Req.getDefaultInstance()).build();
@@ -61,7 +55,6 @@ public final Label label() {
         return Label.of(runMethod(method).getSchemaConceptGetLabelRes().getLabel());
     }
 
-    @Override
     public final Boolean isImplicit() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setSchemaConceptIsImplicitReq(ConceptProto.SchemaConcept.IsImplicit.Req.getDefaultInstance()).build();
@@ -69,7 +62,6 @@ public final Boolean isImplicit() {
         return runMethod(method).getSchemaConceptIsImplicitRes().getImplicit();
     }
 
-    @Override
     public final SomeSchemaConcept label(Label label) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setSchemaConceptSetLabelReq(ConceptProto.SchemaConcept.SetLabel.Req.newBuilder()
@@ -80,7 +72,6 @@ public final SomeSchemaConcept label(Label label) {
     }
 
     @Nullable
-    @Override
     public final SomeSchemaConcept sup() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setSchemaConceptGetSupReq(ConceptProto.SchemaConcept.GetSup.Req.getDefaultInstance()).build();
@@ -91,7 +82,7 @@ public final SomeSchemaConcept sup() {
             case NULL:
                 return null;
             case SCHEMACONCEPT:
-                Concept concept = RemoteConcept.of(response.getSchemaConcept(), tx());
+                Concept concept = Concept.of(response.getSchemaConcept(), tx());
                 return equalsCurrentBaseType(concept) ? asCurrentBaseType(concept) : null;
             default:
                 throw GraknClientException.unreachableStatement("Unexpected response " + response);
@@ -99,12 +90,10 @@ public final SomeSchemaConcept sup() {
 
     }
 
-    @Override
     public final Stream<SomeSchemaConcept> sups() {
         return tx().sups(this).filter(this::equalsCurrentBaseType).map(this::asCurrentBaseType);
     }
 
-    @Override
     public final Stream<SomeSchemaConcept> subs() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setSchemaConceptSubsReq(ConceptProto.SchemaConcept.Subs.Req.getDefaultInstance()).build();
@@ -113,20 +102,19 @@ public final Stream<SomeSchemaConcept> subs() {
         return conceptStream(iteratorId, res -> res.getSchemaConceptSubsIterRes().getSchemaConcept()).map(this::asCurrentBaseType);
     }
 
-    @Override
-    public final LabelId labelId() {
-        throw new UnsupportedOperationException(); // TODO: remove from API
-    }
+    abstract boolean equalsCurrentBaseType(Concept other);
 
+    @Deprecated
+    @CheckReturnValue
     @Override
-    public final Stream<Rule> whenRules() {
-        throw new UnsupportedOperationException(); // TODO: remove from API
+    public SchemaConcept asSchemaConcept() {
+        return this;
     }
 
+    @Deprecated
+    @CheckReturnValue
     @Override
-    public final Stream<Rule> thenRules() {
-        throw new UnsupportedOperationException(); // TODO: remove from API
+    public boolean isSchemaConcept() {
+        return true;
     }
-
-    abstract boolean equalsCurrentBaseType(Concept other);
 }
diff --git a/concept/RemoteThing.java b/concept/Thing.java
similarity index 81%
rename from concept/RemoteThing.java
rename to concept/Thing.java
index 0477388f15..3bb5aac7aa 100644
--- a/concept/RemoteThing.java
+++ b/concept/Thing.java
@@ -21,16 +21,9 @@
 
 import grakn.client.GraknClient;
 import grakn.client.rpc.RequestBuilder;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.thing.Attribute;
-import grakn.core.concept.thing.Relation;
-import grakn.core.concept.thing.Thing;
-import grakn.core.concept.type.AttributeType;
-import grakn.core.concept.type.Role;
-import grakn.core.concept.type.Type;
 import grakn.protocol.session.ConceptProto;
 
+import javax.annotation.CheckReturnValue;
 import java.util.Arrays;
 import java.util.stream.Stream;
 
@@ -40,22 +33,20 @@
  * @param <SomeThing> The exact type of this class
  * @param <SomeType>  the type of an instance of this class
  */
-abstract class RemoteThing<SomeThing extends Thing, SomeType extends Type> extends RemoteConcept<SomeThing> implements Thing {
+public abstract class Thing<SomeThing extends Thing, SomeType extends Type> extends Concept<SomeThing>  {
 
-    RemoteThing(GraknClient.Transaction tx, ConceptId id) {
+    Thing(GraknClient.Transaction tx, ConceptId id) {
         super(tx, id);
     }
 
-    @Override
     public final SomeType type() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setThingTypeReq(ConceptProto.Thing.Type.Req.getDefaultInstance()).build();
 
-        Concept concept = RemoteConcept.of(runMethod(method).getThingTypeRes().getType(), tx());
+        Concept concept = Concept.of(runMethod(method).getThingTypeRes().getType(), tx());
         return asCurrentType(concept);
     }
 
-    @Override
     public final boolean isInferred() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setThingIsInferredReq(ConceptProto.Thing.IsInferred.Req.getDefaultInstance()).build();
@@ -63,37 +54,33 @@ public final boolean isInferred() {
         return runMethod(method).getThingIsInferredRes().getInferred();
     }
 
-    @Override
     public final Stream<Attribute<?>> keys(AttributeType... attributeTypes) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setThingKeysReq(ConceptProto.Thing.Keys.Req.newBuilder()
-                                         .addAllAttributeTypes(RequestBuilder.Concept.concepts(Arrays.asList(attributeTypes)))).build();
+                                         .addAllAttributeTypes(RequestBuilder.ConceptMessage.concepts(Arrays.asList(attributeTypes)))).build();
 
         int iteratorId = runMethod(method).getThingKeysIter().getId();
         return conceptStream(iteratorId, res -> res.getThingKeysIterRes().getAttribute()).map(Concept::asAttribute);
     }
 
-    @Override
     public final Stream<Attribute<?>> attributes(AttributeType... attributeTypes) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setThingAttributesReq(ConceptProto.Thing.Attributes.Req.newBuilder()
-                                               .addAllAttributeTypes(RequestBuilder.Concept.concepts(Arrays.asList(attributeTypes)))).build();
+                                               .addAllAttributeTypes(RequestBuilder.ConceptMessage.concepts(Arrays.asList(attributeTypes)))).build();
 
         int iteratorId = runMethod(method).getThingAttributesIter().getId();
         return conceptStream(iteratorId, res -> res.getThingAttributesIterRes().getAttribute()).map(Concept::asAttribute);
     }
 
-    @Override
     public final Stream<Relation> relations(Role... roles) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setThingRelationsReq(ConceptProto.Thing.Relations.Req.newBuilder()
-                                              .addAllRoles(RequestBuilder.Concept.concepts(Arrays.asList(roles)))).build();
+                                              .addAllRoles(RequestBuilder.ConceptMessage.concepts(Arrays.asList(roles)))).build();
 
         int iteratorId = runMethod(method).getThingRelationsIter().getId();
         return conceptStream(iteratorId, res -> res.getThingRelationsIterRes().getRelation()).map(Concept::asRelation);
     }
 
-    @Override
     public final Stream<Role> roles() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setThingRolesReq(ConceptProto.Thing.Roles.Req.getDefaultInstance()).build();
@@ -102,34 +89,45 @@ public final Stream<Role> roles() {
         return conceptStream(iteratorId, res -> res.getThingRolesIterRes().getRole()).map(Concept::asRole);
     }
 
-    @Override
     public final SomeThing has(Attribute attribute) {
         relhas(attribute);
         return asCurrentBaseType(this);
     }
 
-    @Override
     @Deprecated
     public final Relation relhas(Attribute attribute) {
         // TODO: replace usage of this method as a getter, with relations(Attribute attribute)
         // TODO: then remove this method altogether and just use has(Attribute attribute)
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setThingRelhasReq(ConceptProto.Thing.Relhas.Req.newBuilder()
-                                           .setAttribute(RequestBuilder.Concept.concept(attribute))).build();
+                                           .setAttribute(RequestBuilder.ConceptMessage.from(attribute))).build();
 
-        Concept concept = RemoteConcept.of(runMethod(method).getThingRelhasRes().getRelation(), tx());
+        Concept concept = Concept.of(runMethod(method).getThingRelhasRes().getRelation(), tx());
         return concept.asRelation();
     }
 
-    @Override
     public final SomeThing unhas(Attribute attribute) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setThingUnhasReq(ConceptProto.Thing.Unhas.Req.newBuilder()
-                                          .setAttribute(RequestBuilder.Concept.concept(attribute))).build();
+                                          .setAttribute(RequestBuilder.ConceptMessage.from(attribute))).build();
 
         runMethod(method);
         return asCurrentBaseType(this);
     }
 
     abstract SomeType asCurrentType(Concept concept);
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public Thing asThing() {
+        return this;
+    }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public boolean isThing() {
+        return true;
+    }
 }
diff --git a/concept/RemoteType.java b/concept/Type.java
similarity index 87%
rename from concept/RemoteType.java
rename to concept/Type.java
index d462806334..d25bdd8282 100644
--- a/concept/RemoteType.java
+++ b/concept/Type.java
@@ -21,14 +21,9 @@
 
 import grakn.client.GraknClient;
 import grakn.client.rpc.RequestBuilder;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.thing.Thing;
-import grakn.core.concept.type.AttributeType;
-import grakn.core.concept.type.Role;
-import grakn.core.concept.type.Type;
 import grakn.protocol.session.ConceptProto;
 
+import javax.annotation.CheckReturnValue;
 import java.util.stream.Stream;
 
 /**
@@ -37,13 +32,12 @@
  * @param <SomeType>  The exact type of this class
  * @param <SomeThing> the exact type of instances of this class
  */
-abstract class RemoteType<SomeType extends Type, SomeThing extends Thing> extends RemoteSchemaConcept<SomeType> implements Type {
+public abstract class Type<SomeType extends Type, SomeThing extends Thing> extends SchemaConcept<SomeType> {
 
-    RemoteType(GraknClient.Transaction tx, ConceptId id) {
+    Type(GraknClient.Transaction tx, ConceptId id) {
         super(tx, id);
     }
 
-    @Override
     public final Stream<SomeThing> instances() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setTypeInstancesReq(ConceptProto.Type.Instances.Req.getDefaultInstance()).build();
@@ -52,7 +46,6 @@ public final Stream<SomeThing> instances() {
         return conceptStream(iteratorId, res -> res.getTypeInstancesIterRes().getThing()).map(this::asInstance);
     }
 
-    @Override
     public final Boolean isAbstract() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setTypeIsAbstractReq(ConceptProto.Type.IsAbstract.Req.getDefaultInstance()).build();
@@ -60,7 +53,6 @@ public final Boolean isAbstract() {
         return runMethod(method).getTypeIsAbstractRes().getAbstract();
     }
 
-    @Override
     public final SomeType isAbstract(Boolean isAbstract) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setTypeSetAbstractReq(ConceptProto.Type.SetAbstract.Req.newBuilder()
@@ -70,7 +62,6 @@ public final SomeType isAbstract(Boolean isAbstract) {
         return asCurrentBaseType(this);
     }
 
-    @Override
     public final Stream<AttributeType> keys() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setTypeKeysReq(ConceptProto.Type.Keys.Req.getDefaultInstance()).build();
@@ -79,7 +70,6 @@ public final Stream<AttributeType> keys() {
         return conceptStream(iteratorId, res -> res.getTypeKeysIterRes().getAttributeType()).map(Concept::asAttributeType);
     }
 
-    @Override
     public final Stream<AttributeType> attributes() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setTypeAttributesReq(ConceptProto.Type.Attributes.Req.getDefaultInstance()).build();
@@ -88,7 +78,6 @@ public final Stream<AttributeType> attributes() {
         return conceptStream(iteratorId, res -> res.getTypeAttributesIterRes().getAttributeType()).map(Concept::asAttributeType);
     }
 
-    @Override
     public final Stream<Role> playing() {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setTypePlayingReq(ConceptProto.Type.Playing.Req.getDefaultInstance()).build();
@@ -97,65 +86,73 @@ public final Stream<Role> playing() {
         return conceptStream(iteratorId, res -> res.getTypePlayingIterRes().getRole()).map(Concept::asRole);
     }
 
-    @Override
     public final SomeType key(AttributeType attributeType) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setTypeKeyReq(ConceptProto.Type.Key.Req.newBuilder()
-                                       .setAttributeType(RequestBuilder.Concept.concept(attributeType))).build();
+                                       .setAttributeType(RequestBuilder.ConceptMessage.from(attributeType))).build();
 
         runMethod(method);
         return asCurrentBaseType(this);
     }
 
-    @Override
     public final SomeType has(AttributeType attributeType) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setTypeHasReq(ConceptProto.Type.Has.Req.newBuilder()
-                                       .setAttributeType(RequestBuilder.Concept.concept(attributeType))).build();
+                                       .setAttributeType(RequestBuilder.ConceptMessage.from(attributeType))).build();
 
         runMethod(method);
         return asCurrentBaseType(this);
     }
 
-    @Override
     public final SomeType plays(Role role) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setTypePlaysReq(ConceptProto.Type.Plays.Req.newBuilder()
-                                         .setRole(RequestBuilder.Concept.concept(role))).build();
+                                         .setRole(RequestBuilder.ConceptMessage.from(role))).build();
 
         runMethod(method);
         return asCurrentBaseType(this);
     }
 
-    @Override
     public final SomeType unkey(AttributeType attributeType) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setTypeUnkeyReq(ConceptProto.Type.Unkey.Req.newBuilder()
-                                         .setAttributeType(RequestBuilder.Concept.concept(attributeType))).build();
+                                         .setAttributeType(RequestBuilder.ConceptMessage.from(attributeType))).build();
 
         runMethod(method);
         return asCurrentBaseType(this);
     }
 
-    @Override
     public final SomeType unhas(AttributeType attributeType) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setTypeUnhasReq(ConceptProto.Type.Unhas.Req.newBuilder()
-                                         .setAttributeType(RequestBuilder.Concept.concept(attributeType))).build();
+                                         .setAttributeType(RequestBuilder.ConceptMessage.from(attributeType))).build();
 
         runMethod(method);
         return asCurrentBaseType(this);
     }
 
-    @Override
     public final SomeType unplay(Role role) {
         ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder()
                 .setTypeUnplayReq(ConceptProto.Type.Unplay.Req.newBuilder()
-                                          .setRole(RequestBuilder.Concept.concept(role))).build();
+                                          .setRole(RequestBuilder.ConceptMessage.from(role))).build();
 
         runMethod(method);
         return asCurrentBaseType(this);
     }
 
     protected abstract SomeThing asInstance(Concept concept);
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public Type asType() {
+        return this;
+    }
+
+    @Deprecated
+    @CheckReturnValue
+    @Override
+    public boolean isType() {
+        return true;
+    }
 }
diff --git a/concept/test/BUILD b/concept/test/BUILD
deleted file mode 100644
index 52f8ada77e..0000000000
--- a/concept/test/BUILD
+++ /dev/null
@@ -1,53 +0,0 @@
-#
-# GRAKN.AI - THE KNOWLEDGE GRAPH
-# Copyright (C) 2019 Grakn Labs Ltd
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as
-# published by the Free Software Foundation, either version 3 of the
-# License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-#
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-#
-
-package(default_visibility = ["//visibility:__pkg__"])
-
-load("@graknlabs_build_tools//checkstyle:rules.bzl", "checkstyle_test")
-
-java_test(
-    name = "remote-concept-it",
-    srcs = ["RemoteConceptIT.java"],
-    test_class = "grakn.client.concept.test.RemoteConceptIT",
-    deps = [
-        # Grakn Core dependencies
-        "//:client-java",
-        "@graknlabs_grakn_core//concept:concept",
-        "@graknlabs_grakn_core//test-integration/rule:grakn-test-server",
-
-        # Grakn Labs dependencies
-        "@graknlabs_graql//java:graql",
-
-        # Maven External dependencies
-        "//dependencies/maven/artifacts/org/hamcrest:hamcrest-library",
-        "//dependencies/maven/artifacts/org/slf4j:slf4j-api", # TODO: Do we still need this?
-    ],
-    size = "large",
-    classpath_resources = [
-        "@graknlabs_grakn_core//test-integration/resources:logback-test",
-        "@graknlabs_grakn_core//test-integration/resources:cassandra-embedded",
-        "@graknlabs_grakn_core//server:conf/grakn.properties"
-    ]
-)
-
-
-checkstyle_test(
-    name = "checkstyle",
-    targets = [":remote-concept-it"],
-    license_type = "apache"
-)
diff --git a/rpc/RequestBuilder.java b/rpc/RequestBuilder.java
index e10e3ba8de..8318afb705 100644
--- a/rpc/RequestBuilder.java
+++ b/rpc/RequestBuilder.java
@@ -20,10 +20,10 @@
 package grakn.client.rpc;
 
 import grakn.client.GraknClient;
+import grakn.client.concept.AttributeType;
+import grakn.client.concept.ConceptId;
+import grakn.client.concept.Label;
 import grakn.client.exception.GraknClientException;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.Label;
-import grakn.core.concept.type.AttributeType;
 import grakn.protocol.session.ConceptProto;
 import grakn.protocol.keyspace.KeyspaceProto;
 import grakn.protocol.session.SessionProto;
@@ -41,7 +41,6 @@
  */
 public class RequestBuilder {
 
-
     public static class Session {
 
         public static SessionProto.Session.Open.Req open(String keyspace) {
@@ -109,7 +108,7 @@ public static SessionProto.Transaction.Req getConcept(ConceptId id) {
         public static SessionProto.Transaction.Req getAttributes(Object value) {
             return SessionProto.Transaction.Req.newBuilder()
                     .setGetAttributesReq(SessionProto.Transaction.GetAttributes.Req.newBuilder()
-                                                 .setValue(Concept.attributeValue(value))
+                                                 .setValue(ConceptMessage.attributeValue(value))
                     ).build();
         }
 
@@ -122,7 +121,7 @@ public static SessionProto.Transaction.Req putEntityType(Label label) {
         public static SessionProto.Transaction.Req putAttributeType(Label label, AttributeType.DataType<?> dataType) {
             SessionProto.Transaction.PutAttributeType.Req request = SessionProto.Transaction.PutAttributeType.Req.newBuilder()
                     .setLabel(label.getValue())
-                    .setDataType(Concept.dataType(dataType))
+                    .setDataType(ConceptMessage.setDataType(dataType))
                     .build();
 
             return SessionProto.Transaction.Req.newBuilder().setPutAttributeTypeReq(request).build();
@@ -161,16 +160,16 @@ public static SessionProto.Transaction.Req iterate(int iteratorId) {
     /**
      * An RPC Request Builder class for Concept messages
      */
-    public static class Concept {
+    public static class ConceptMessage {
 
-        public static ConceptProto.Concept concept(grakn.core.concept.Concept concept) {
+        public static ConceptProto.Concept from(grakn.client.concept.Concept concept) {
             return ConceptProto.Concept.newBuilder()
                     .setId(concept.id().getValue())
                     .setBaseType(getBaseType(concept))
                     .build();
         }
 
-        private static ConceptProto.Concept.BASE_TYPE getBaseType(grakn.core.concept.Concept concept) {
+        private static ConceptProto.Concept.BASE_TYPE getBaseType(grakn.client.concept.Concept concept) {
             if (concept.isEntityType()) {
                 return ConceptProto.Concept.BASE_TYPE.ENTITY_TYPE;
             } else if (concept.isRelationType()) {
@@ -194,8 +193,8 @@ private static ConceptProto.Concept.BASE_TYPE getBaseType(grakn.core.concept.Con
             }
         }
 
-        public static Collection<ConceptProto.Concept> concepts(Collection<grakn.core.concept.Concept> concepts) {
-            return concepts.stream().map(Concept::concept).collect(toList());
+        public static Collection<ConceptProto.Concept> concepts(Collection<grakn.client.concept.Concept> concepts) {
+            return concepts.stream().map(ConceptMessage::from).collect(toList());
         }
 
         public static ConceptProto.ValueObject attributeValue(Object value) {
@@ -223,42 +222,42 @@ public static ConceptProto.ValueObject attributeValue(Object value) {
             return builder.build();
         }
 
-        public static AttributeType.DataType<?> dataType(ConceptProto.AttributeType.DATA_TYPE dataType) {
+        public static grakn.client.concept.AttributeType.DataType dataType(ConceptProto.AttributeType.DATA_TYPE dataType) {
             switch (dataType) {
                 case STRING:
-                    return AttributeType.DataType.STRING;
+                    return grakn.client.concept.AttributeType.DataType.STRING;
                 case BOOLEAN:
-                    return AttributeType.DataType.BOOLEAN;
+                    return  grakn.client.concept.AttributeType.DataType.BOOLEAN;
                 case INTEGER:
-                    return AttributeType.DataType.INTEGER;
+                    return  grakn.client.concept.AttributeType.DataType.INTEGER;
                 case LONG:
-                    return AttributeType.DataType.LONG;
+                    return  grakn.client.concept.AttributeType.DataType.LONG;
                 case FLOAT:
-                    return AttributeType.DataType.FLOAT;
+                    return  grakn.client.concept.AttributeType.DataType.FLOAT;
                 case DOUBLE:
-                    return AttributeType.DataType.DOUBLE;
+                    return  grakn.client.concept.AttributeType.DataType.DOUBLE;
                 case DATE:
-                    return AttributeType.DataType.DATE;
+                    return  grakn.client.concept.AttributeType.DataType.DATE;
                 default:
                 case UNRECOGNIZED:
                     throw new IllegalArgumentException("Unrecognised " + dataType);
             }
         }
 
-        static ConceptProto.AttributeType.DATA_TYPE dataType(AttributeType.DataType<?> dataType) {
-            if (dataType.equals(AttributeType.DataType.STRING)) {
+        static ConceptProto.AttributeType.DATA_TYPE setDataType(grakn.client.concept.AttributeType.DataType dataType) {
+            if (dataType.equals( grakn.client.concept.AttributeType.DataType.STRING)) {
                 return ConceptProto.AttributeType.DATA_TYPE.STRING;
-            } else if (dataType.equals(AttributeType.DataType.BOOLEAN)) {
+            } else if (dataType.equals( grakn.client.concept.AttributeType.DataType.BOOLEAN)) {
                 return ConceptProto.AttributeType.DATA_TYPE.BOOLEAN;
-            } else if (dataType.equals(AttributeType.DataType.INTEGER)) {
+            } else if (dataType.equals( grakn.client.concept.AttributeType.DataType.INTEGER)) {
                 return ConceptProto.AttributeType.DATA_TYPE.INTEGER;
-            } else if (dataType.equals(AttributeType.DataType.LONG)) {
+            } else if (dataType.equals( grakn.client.concept.AttributeType.DataType.LONG)) {
                 return ConceptProto.AttributeType.DATA_TYPE.LONG;
-            } else if (dataType.equals(AttributeType.DataType.FLOAT)) {
+            } else if (dataType.equals( grakn.client.concept.AttributeType.DataType.FLOAT)) {
                 return ConceptProto.AttributeType.DATA_TYPE.FLOAT;
-            } else if (dataType.equals(AttributeType.DataType.DOUBLE)) {
+            } else if (dataType.equals( grakn.client.concept.AttributeType.DataType.DOUBLE)) {
                 return ConceptProto.AttributeType.DATA_TYPE.DOUBLE;
-            } else if (dataType.equals(AttributeType.DataType.DATE)) {
+            } else if (dataType.equals( grakn.client.concept.AttributeType.DataType.DATE)) {
                 return ConceptProto.AttributeType.DATA_TYPE.DATE;
             } else {
                 throw GraknClientException.unreachableStatement("Unrecognised " + dataType);
@@ -269,7 +268,7 @@ static ConceptProto.AttributeType.DATA_TYPE dataType(AttributeType.DataType<?> d
     /**
      * An RPC Request Builder class for Keyspace Service
      */
-    public static class Keyspace {
+    public static class KeyspaceMessage {
 
         public static KeyspaceProto.Keyspace.Delete.Req delete(String name, String username, String password) {
             KeyspaceProto.Keyspace.Delete.Req.Builder builder = KeyspaceProto.Keyspace.Delete.Req.newBuilder();
diff --git a/rpc/ResponseReader.java b/rpc/ResponseReader.java
index 3379d0b955..931686294f 100644
--- a/rpc/ResponseReader.java
+++ b/rpc/ResponseReader.java
@@ -20,21 +20,21 @@
 package grakn.client.rpc;
 
 import grakn.client.GraknClient;
-import grakn.client.concept.RemoteConcept;
-import grakn.core.concept.Concept;
-import grakn.core.concept.ConceptId;
-import grakn.core.concept.answer.Answer;
-import grakn.core.concept.answer.AnswerGroup;
-import grakn.core.concept.answer.ConceptList;
-import grakn.core.concept.answer.ConceptMap;
-import grakn.core.concept.answer.ConceptSet;
-import grakn.core.concept.answer.ConceptSetMeasure;
-import grakn.core.concept.answer.Explanation;
-import grakn.core.concept.answer.Numeric;
+import grakn.client.concept.Concept;
 import grakn.protocol.session.AnswerProto;
 import graql.lang.Graql;
 import graql.lang.pattern.Pattern;
 import graql.lang.statement.Variable;
+import grakn.client.answer.Answer;
+import grakn.client.answer.AnswerGroup;
+import grakn.client.answer.ConceptList;
+import grakn.client.answer.ConceptMap;
+import grakn.client.answer.ConceptSet;
+import grakn.client.answer.ConceptSetMeasure;
+import grakn.client.answer.Numeric;
+import grakn.client.answer.Explanation;
+
+import grakn.client.concept.ConceptId;
 
 import java.text.NumberFormat;
 import java.text.ParseException;
@@ -81,7 +81,7 @@ private static Explanation explanation(AnswerProto.Explanation res, GraknClient.
 
     private static AnswerGroup<?> answerGroup(AnswerProto.AnswerGroup res, GraknClient.Transaction tx) {
         return new AnswerGroup<>(
-                RemoteConcept.of(res.getOwner(), tx),
+                Concept.of(res.getOwner(), tx),
                 res.getAnswersList().stream().map(answer -> answer(answer, tx)).collect(toList())
         );
     }
@@ -89,7 +89,7 @@ private static AnswerGroup<?> answerGroup(AnswerProto.AnswerGroup res, GraknClie
     private static ConceptMap conceptMap(AnswerProto.ConceptMap res, GraknClient.Transaction tx) {
         Map<Variable, Concept> answers = new HashMap<>();
         res.getMapMap().forEach(
-                (resVar, resConcept) -> answers.put(new Variable(resVar), RemoteConcept.of(resConcept, tx))
+                (resVar, resConcept) -> answers.put(new Variable(resVar), Concept.of(resConcept, tx))
         );
         return new ConceptMap(Collections.unmodifiableMap(answers), explanation(res.getExplanation(), tx));
     }
diff --git a/test/behaviour/concept/BUILD b/test/behaviour/concept/BUILD
new file mode 100644
index 0000000000..dccd89e396
--- /dev/null
+++ b/test/behaviour/concept/BUILD
@@ -0,0 +1,60 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+
+package(default_visibility = ["//visibility:__subpackages__"])
+
+load("@graknlabs_build_tools//checkstyle:rules.bzl", "checkstyle_test")
+
+java_test(
+    name = "concept-it",
+    srcs = ["ConceptIT.java"],
+    test_class = "grakn.client.test.behaviour.concept.ConceptIT",
+    deps = [
+        # Grakn Core dependencies
+        "//:client-java",
+        "//test/setup:grakn-setup",
+        "//test/setup:grakn-properties",
+
+        # Grakn Labs dependencies
+        "@graknlabs_graql//java:graql",
+
+        # Maven External dependencies
+        "//dependencies/maven/artifacts/org/hamcrest:hamcrest-library",
+        "//dependencies/maven/artifacts/org/slf4j:slf4j-api", # TODO: Do we still need this?
+    ],
+    size = "large",
+    classpath_resources = [
+        "//test/setup:logback",
+    ],
+    data = [
+        "@graknlabs_grakn_core//:assemble-linux-targz", # Make sure to pass the path in args below
+    ],
+    args = [ # The order of the arguments matter
+        "grakn-core", # Keep at index 0, will be accessible at args[1]
+        "$(location @graknlabs_grakn_core//:assemble-linux-targz)", # Keep at index 1, will be accessible at args[2]
+    ],
+)
+
+
+checkstyle_test(
+    name = "checkstyle",
+    targets = [":concept-it"],
+    license_type = "apache"
+)
diff --git a/concept/test/RemoteConceptIT.java b/test/behaviour/concept/ConceptIT.java
similarity index 94%
rename from concept/test/RemoteConceptIT.java
rename to test/behaviour/concept/ConceptIT.java
index 83182c0011..24d7d67a94 100644
--- a/concept/test/RemoteConceptIT.java
+++ b/test/behaviour/concept/ConceptIT.java
@@ -17,37 +17,38 @@
  * under the License.
  */
 
-package grakn.client.concept.test;
+package grakn.client.test.behaviour.concept;
 
 import grakn.client.GraknClient;
-import grakn.core.concept.Label;
-import grakn.core.concept.thing.Attribute;
-import grakn.core.concept.thing.Entity;
-import grakn.core.concept.thing.Relation;
-import grakn.core.concept.thing.Thing;
-import grakn.core.concept.type.AttributeType;
-import grakn.core.concept.type.AttributeType.DataType;
-import grakn.core.concept.type.EntityType;
-import grakn.core.concept.type.RelationType;
-import grakn.core.concept.type.Role;
-import grakn.core.concept.type.Rule;
-import grakn.core.rule.GraknTestServer;
+import grakn.client.concept.Attribute;
+import grakn.client.concept.AttributeType;
+import grakn.client.concept.AttributeType.DataType;
+import grakn.client.concept.Entity;
+import grakn.client.concept.EntityType;
+import grakn.client.concept.Label;
+import grakn.client.concept.Relation;
+import grakn.client.concept.RelationType;
+import grakn.client.concept.Role;
+import grakn.client.concept.Rule;
+import grakn.client.concept.Thing;
+import grakn.client.test.setup.GraknProperties;
+import grakn.client.test.setup.GraknSetup;
 import graql.lang.pattern.Pattern;
 import org.junit.After;
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
-import org.junit.ClassRule;
 import org.junit.Ignore;
 import org.junit.Test;
 
-import java.nio.file.Paths;
+import java.io.IOException;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.TimeoutException;
 
 import static graql.lang.Graql.var;
 import static java.util.stream.Collectors.toList;
@@ -63,16 +64,13 @@
 /**
  * Integration Tests for testing methods of all subclasses of grakn.client.concept.RemoteConcept.
  */
-public class RemoteConceptIT {
+public class ConceptIT {
 
-    @ClassRule
-    public static final GraknTestServer server = new GraknTestServer(
-            Paths.get("external/graknlabs_grakn_core/server/conf/grakn.properties"),
-            Paths.get("external/graknlabs_grakn_core/test-integration/resources/cassandra-embedded.yaml")
-    );
+    private static GraknClient client;
     private static GraknClient.Session session;
-    private static int EMAIL_COUNTER = 0;
     private GraknClient.Transaction tx;
+
+    private static int EMAIL_COUNTER = 0;
     // Attribute Type Labels
     private Label EMAIL = Label.of("email");
     private Label NAME = Label.of("name");
@@ -137,14 +135,20 @@ public class RemoteConceptIT {
     private Relation selfEmployment;
 
     @BeforeClass
-    public static void setUpClass() {
+    public static void setUpClass() throws InterruptedException, IOException, TimeoutException {
+        GraknSetup.bootup();
+
         String randomKeyspace = "a" + UUID.randomUUID().toString().replaceAll("-", "");
-        session = new GraknClient(server.grpcUri().toString()).session(randomKeyspace);
+        String address = System.getProperty(GraknProperties.GRAKN_ADDRESS);
+        client = new GraknClient(address);
+        session = client.session(randomKeyspace);
     }
 
     @AfterClass
-    public static void closeSession() {
+    public static void closeSession() throws InterruptedException, TimeoutException, IOException {
         session.close();
+        client.close();
+        GraknSetup.shutdown();
     }
 
     @Before
diff --git a/test/deployment/src/test/java/application/MavenApplicationTest.java b/test/deployment/src/test/java/application/MavenApplicationTest.java
index 5bbbef389d..9ffce47765 100644
--- a/test/deployment/src/test/java/application/MavenApplicationTest.java
+++ b/test/deployment/src/test/java/application/MavenApplicationTest.java
@@ -1,7 +1,7 @@
 package application;
 
 import grakn.client.GraknClient;
-import grakn.core.concept.answer.ConceptMap;
+import grakn.client.answer.ConceptMap;
 import graql.lang.Graql;
 import org.junit.Test;