diff --git a/trustgraph-base/trustgraph/api/flow.py b/trustgraph-base/trustgraph/api/flow.py
index d06a6327..6fd9c723 100644
--- a/trustgraph-base/trustgraph/api/flow.py
+++ b/trustgraph-base/trustgraph/api/flow.py
@@ -10,12 +10,27 @@ import json
 import base64
 
 from .. knowledge import hash, Uri, Literal
+from .. schema import IRI, LITERAL
 from . types import Triple
 from . exceptions import ProtocolException
 
+
 def to_value(x):
-    if x["e"]: return Uri(x["v"])
-    return Literal(x["v"])
+    """Convert wire format to Uri or Literal."""
+    if x.get("t") == IRI:
+        return Uri(x.get("i", ""))
+    elif x.get("t") == LITERAL:
+        return Literal(x.get("v", ""))
+    # Fallback for any other type
+    return Literal(x.get("v", x.get("i", "")))
+
+
+def from_value(v):
+    """Convert Uri or Literal to wire format."""
+    if isinstance(v, Uri):
+        return {"t": IRI, "i": str(v)}
+    else:
+        return {"t": LITERAL, "v": str(v)}
 
 class Flow:
     """
@@ -751,17 +766,17 @@ class FlowInstance:
         if s:
             if not isinstance(s, Uri):
                 raise RuntimeError("s must be Uri")
-            input["s"] = { "v": str(s), "e": isinstance(s, Uri), }
-            
+            input["s"] = from_value(s)
+
         if p:
             if not isinstance(p, Uri):
                 raise RuntimeError("p must be Uri")
-            input["p"] = { "v": str(p), "e": isinstance(p, Uri), }
+            input["p"] = from_value(p)
 
         if o:
             if not isinstance(o, Uri) and not isinstance(o, Literal):
                 raise RuntimeError("o must be Uri or Literal")
-            input["o"] = { "v": str(o), "e": isinstance(o, Uri), }
+            input["o"] = from_value(o)
 
         object = self.request(
             "service/triples",
@@ -834,9 +849,9 @@ class FlowInstance:
         if metadata:
             metadata.emit(
                 lambda t: triples.append({
-                    "s": { "v": t["s"], "e": isinstance(t["s"], Uri) },
-                    "p": { "v": t["p"], "e": isinstance(t["p"], Uri) },
-                    "o": { "v": t["o"], "e": isinstance(t["o"], Uri) }
+                    "s": from_value(t["s"]),
+                    "p": from_value(t["p"]),
+                    "o": from_value(t["o"]),
                 })
             )
 
@@ -913,9 +928,9 @@ class FlowInstance:
         if metadata:
             metadata.emit(
                 lambda t: triples.append({
-                    "s": { "v": t["s"], "e": isinstance(t["s"], Uri) },
-                    "p": { "v": t["p"], "e": isinstance(t["p"], Uri) },
-                    "o": { "v": t["o"], "e": isinstance(t["o"], Uri) }
+                    "s": from_value(t["s"]),
+                    "p": from_value(t["p"]),
+                    "o": from_value(t["o"]),
                 })
             )
 
diff --git a/trustgraph-base/trustgraph/api/knowledge.py b/trustgraph-base/trustgraph/api/knowledge.py
index 23f6c9f2..1fae350c 100644
--- a/trustgraph-base/trustgraph/api/knowledge.py
+++ b/trustgraph-base/trustgraph/api/knowledge.py
@@ -10,11 +10,18 @@ import json
 import base64
 
 from .. knowledge import hash, Uri, Literal
+from .. schema import IRI, LITERAL
 from . types import Triple
 
+
 def to_value(x):
-    if x["e"]: return Uri(x["v"])
-    return Literal(x["v"])
+    """Convert wire format to Uri or Literal."""
+    if x.get("t") == IRI:
+        return Uri(x.get("i", ""))
+    elif x.get("t") == LITERAL:
+        return Literal(x.get("v", ""))
+    # Fallback for any other type
+    return Literal(x.get("v", x.get("i", "")))
 
 class Knowledge:
     """
diff --git a/trustgraph-base/trustgraph/api/library.py b/trustgraph-base/trustgraph/api/library.py
index b068f627..e50dc0aa 100644
--- a/trustgraph-base/trustgraph/api/library.py
+++ b/trustgraph-base/trustgraph/api/library.py
@@ -12,13 +12,28 @@ import logging
 
 from . types import DocumentMetadata, ProcessingMetadata, Triple
 from .. knowledge import hash, Uri, Literal
+from .. schema import IRI, LITERAL
 from . exceptions import *
 
 logger = logging.getLogger(__name__)
 
+
 def to_value(x):
-    if x["e"]: return Uri(x["v"])
-    return Literal(x["v"])
+    """Convert wire format to Uri or Literal."""
+    if x.get("t") == IRI:
+        return Uri(x.get("i", ""))
+    elif x.get("t") == LITERAL:
+        return Literal(x.get("v", ""))
+    # Fallback for any other type
+    return Literal(x.get("v", x.get("i", "")))
+
+
+def from_value(v):
+    """Convert Uri or Literal to wire format."""
+    if isinstance(v, Uri):
+        return {"t": IRI, "i": str(v)}
+    else:
+        return {"t": LITERAL, "v": str(v)}
 
 class Library:
     """
@@ -118,18 +133,18 @@ class Library:
             if isinstance(metadata, list):
                 triples = [
                     {
-                        "s": { "v": t.s, "e": isinstance(t.s, Uri) },
-                        "p": { "v": t.p, "e": isinstance(t.p, Uri) },
-                        "o": { "v": t.o, "e": isinstance(t.o, Uri) }
+                        "s": from_value(t.s),
+                        "p": from_value(t.p),
+                        "o": from_value(t.o),
                     }
                     for t in metadata
                 ]
             elif hasattr(metadata, "emit"):
                 metadata.emit(
                     lambda t: triples.append({
-                        "s": { "v": t["s"], "e": isinstance(t["s"], Uri) },
-                        "p": { "v": t["p"], "e": isinstance(t["p"], Uri) },
-                        "o": { "v": t["o"], "e": isinstance(t["o"], Uri) }
+                        "s": from_value(t["s"]),
+                        "p": from_value(t["p"]),
+                        "o": from_value(t["o"]),
                     })
                 )
             else:
@@ -315,9 +330,9 @@ class Library:
                 "comments": metadata.comments,
                 "metadata": [
                     {
-                        "s": { "v": t["s"], "e": isinstance(t["s"], Uri) },
-                        "p": { "v": t["p"], "e": isinstance(t["p"], Uri) },
-                        "o": { "v": t["o"], "e": isinstance(t["o"], Uri) }
+                        "s": from_value(t["s"]),
+                        "p": from_value(t["p"]),
+                        "o": from_value(t["o"]),
                     }
                     for t in metadata.metadata
                 ],
diff --git a/trustgraph-flow/trustgraph/gateway/dispatch/serialize.py b/trustgraph-flow/trustgraph/gateway/dispatch/serialize.py
index 653ecfd9..8f1cdece 100644
--- a/trustgraph-flow/trustgraph/gateway/dispatch/serialize.py
+++ b/trustgraph-flow/trustgraph/gateway/dispatch/serialize.py
@@ -1,46 +1,37 @@
 
 import base64
 
-from ... schema import Value, Triple, DocumentMetadata, ProcessingMetadata
+from ... schema import Term, Triple, DocumentMetadata, ProcessingMetadata
+from ... messaging.translators.primitives import TermTranslator, TripleTranslator
+
+# Singleton translator instances
+_term_translator = TermTranslator()
+_triple_translator = TripleTranslator()
 
-# DEPRECATED: These functions have been moved to trustgraph.... messaging.translators
-# Use the new messaging translation system instead for consistency and reusability.
-# Examples:
-#   from trustgraph.... messaging.translators.primitives import ValueTranslator
-#   value_translator = ValueTranslator()
-#   pulsar_value = value_translator.to_pulsar({"v": "example", "e": True})
 
 def to_value(x):
-    return Value(value=x["v"], is_uri=x["e"])
+    """Convert dict to Term. Delegates to TermTranslator."""
+    return _term_translator.to_pulsar(x)
+
 
 def to_subgraph(x):
-    return [
-        Triple(
-            s=to_value(t["s"]),
-            p=to_value(t["p"]),
-            o=to_value(t["o"])
-        )
-        for t in x
-    ]
+    """Convert list of dicts to list of Triples. Delegates to TripleTranslator."""
+    return [_triple_translator.to_pulsar(t) for t in x]
+
 
 def serialize_value(v):
-    return {
-        "v": v.value,
-        "e": v.is_uri,
-    }
+    """Convert Term to dict. Delegates to TermTranslator."""
+    return _term_translator.from_pulsar(v)
+
 
 def serialize_triple(t):
-    return {
-        "s": serialize_value(t.s),
-        "p": serialize_value(t.p),
-        "o": serialize_value(t.o)
-    }
+    """Convert Triple to dict. Delegates to TripleTranslator."""
+    return _triple_translator.from_pulsar(t)
+
 
 def serialize_subgraph(sg):
-    return [
-        serialize_triple(t)
-        for t in sg
-    ]
+    """Convert list of Triples to list of dicts."""
+    return [serialize_triple(t) for t in sg]
 
 def serialize_triples(message):
     return {