diff --git a/CHANGELOG.md b/CHANGELOG.md
index 36723ab507..9673b646d9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 <!-- Do Not Erase This Section - Used for tracking unreleased changes -->
 
 ### Added
+- **GFQL schema inference API (#1338)**: Added experimental `graphistry.infer_schema(g)`, `g.infer_schema()`, and `g.bind(infer_schema=True)` for opt-in public `GraphSchema` inference from bound local graph data. Inference derives node/edge property logical types, presence/nullability report details, `label__*` node and relationship labels, and source/destination topology when node label evidence is available. Inferred schemas carry descriptive `GraphSchema.metadata` provenance (`source="inferred"` or `source="mixed"`). Declared schemas remain explicit and take precedence when passed to `infer_schema(..., schema=...)`; `bind(schema=..., infer_schema=True)` is rejected instead of silently merging contracts.
 - **GFQL NetworkX CALL parity (#1058)**: Expanded the local Cypher `graphistry.nx.*` CALL surface with explicit NetworkX dispatch for `degree_centrality`, `closeness_centrality`, `eigenvector_centrality`, `katz_centrality`, `connected_components`, `strongly_connected_components`, `core_number`, and multi-output `hits`, including row and `.write()` coverage.
 - **NetworkX/SciPy optional dependency policy (#1618)**: Declared supported `networkx>=2.5,<4` and optional `scipy>=1.5,<2` ranges for NetworkX-backed GFQL CALL procedures, with runtime version guards and a focused lower/current-upper CI matrix.
 - **GFQL schema Arrow boundary APIs (#1339)**: Added experimental public schema↔Arrow import/export helpers, graph-level Arrow declaration payloads, and opt-in `schema_validate='strict'|'autofix'` enforcement for `plot()`, `upload()`, `to_arrow()`, and `validate_arrow_schema()` when a `GraphSchema` is bound.
diff --git a/docs/source/gfql/schema.rst b/docs/source/gfql/schema.rst
index d85c319a28..a32ea28f9b 100644
--- a/docs/source/gfql/schema.rst
+++ b/docs/source/gfql/schema.rst
@@ -5,8 +5,9 @@ GFQL accepts public schema declarations through the stable
 ``graphistry.schema`` import path. Use this when application code owns a graph
 contract and wants Cypher preflight checks to fail before query execution.
 The API is experimental in this release: the import path and core declaration
-objects are intended to be stable, while inference, coercion, remote transport,
-and planner use are still follow-on surfaces.
+objects are intended to be stable, while coercion, remote transport, and
+planner use are still follow-on surfaces. Inference is also experimental and
+must be requested explicitly.
 
 The schema is optional. When you provide one, PyGraphistry uses it as the
 declared contract for local GFQL validation. When you do not provide one,
@@ -95,6 +96,8 @@ Schema Objects
   ``GraphSchemaCatalog`` used by binder/preflight validation. ``strict=False``
   makes schema-bound ``g.gfql_validate(...)`` permissive by default; callers can
   still override per call with ``g.gfql_validate(..., strict=True)``.
+  ``metadata`` is descriptive provenance for callers and exports; it is not part
+  of validation semantics.
 
 ``NodeType.to_arrow()`` and ``EdgeType.to_arrow()``
   Export declarations as ``pyarrow.Schema`` objects through GFQL's row-schema
@@ -128,8 +131,8 @@ Invalid queries raise ``GFQLValidationError`` with structured context.
 This is a correctness and documentation surface first: applications can state
 what labels, relationship types, properties, and topology they expect, then
 validate user-authored or generated Cypher before running it. The same typed
-contract is also the foundation for later inference, coercion, remote transport,
-and planner/performance work, but this page covers the declared local contract.
+contract is also used by inference and is the foundation for later coercion,
+remote transport, and planner/performance work.
 
 Arrow Boundary Validation
 -------------------------
@@ -163,22 +166,116 @@ boundaries. This is off by default so existing ``plot()``, ``upload()``, and
 Provided vs. Inferred Schema
 ----------------------------
 
-In this release, schemas are **provided**, not inferred. You create
-``NodeType``, ``EdgeType``, and ``GraphSchema`` objects directly and attach them
-with ``graphistry.bind(..., schema=schema)`` or ``g.bind(schema=schema)``.
+You can provide a schema directly or infer one from bound local data.
 
-Without an explicit ``GraphSchema``:
+Use a provided schema when application code owns the contract:
 
-* ``g.gfql_validate(...)`` can still use local dataframe columns already bound
-  on ``g._nodes`` and ``g._edges`` for schema-aware checks.
-* It does not infer node types, edge types, Arrow dtypes, nullability, or
-  topology from data.
+.. code-block:: python
+
+   declared_g = (
+       graphistry
+       .edges(edges_df, "src", "dst")
+       .nodes(nodes_df, "id")
+       .bind(schema=schema)
+   )
+
+Use inference when the graph data should define the first draft contract:
+
+.. code-block:: python
+
+   inferred_base_g = graphistry.edges(edges_df, "src", "dst").nodes(nodes_df, "id")
+   inferred_schema = inferred_base_g.infer_schema()
+   inferred_g = inferred_base_g.bind(schema=inferred_schema)
+
+For one-step local binding, use:
+
+.. code-block:: python
+
+   inferred_g = (
+       graphistry
+       .edges(edges_df, "src", "dst")
+       .nodes(nodes_df, "id")
+       .bind(infer_schema=True)
+   )
+
+Inference is opt-in. ``graphistry.bind(...)`` and ``g.bind(...)`` do not infer a
+schema unless ``infer_schema=True`` is passed.
+
+Inference Rules
+---------------
+
+``graphistry.infer_schema(g)`` and ``g.infer_schema()`` return a public
+``GraphSchema``. They inspect currently bound ``nodes`` and ``edges`` dataframes:
+
+* Node types come from boolean ``label__<Label>`` columns on the node table.
+* Edge types come from boolean ``label__<TYPE>`` columns on the edge table.
+* Node properties are non-label node columns observed on rows for a label.
+* Edge properties are non-label edge columns, excluding the bound source,
+  destination, and edge-id columns.
+* Source/destination topology is inferred when edges reference bound node ids
+  and those nodes have label columns. Edge-only graphs keep edge types and
+  properties, but do not invent endpoint labels.
 * A remote-only graph such as ``graphistry.bind(dataset_id="...")`` has no
   local dataframe columns, so local validation is limited to syntax, compile,
   and structural checks unless you also bind a declared schema.
 
-Schema inference from existing plottables is tracked separately from this
-declared-schema API.
+Inference uses the same Arrow/GFQL row-schema bridge as declared schemas for
+logical property types. The returned ``GraphSchema`` can be passed to
+``g.bind(schema=schema)`` and used by ``g.gfql_validate(...)``.
+
+Inferred schemas include descriptive provenance:
+
+.. code-block:: python
+
+   inferred_schema.metadata["source"] == "inferred"
+
+When declared definitions override inferred definitions through
+``infer_schema(..., schema=schema)``, the returned schema uses
+``metadata["source"] == "mixed"``. This metadata is informational; it does not
+change preflight validation, Arrow validation, or schema equality.
+
+Presence And Nullability
+------------------------
+
+The public ``GraphSchema`` stores the inferred logical type and scalar
+nullability needed by validation. For more detail, request the experimental
+report:
+
+.. code-block:: python
+
+   schema, report = g.infer_schema(return_report=True)
+
+The report tracks property presence separately from type:
+
+``required``
+  The property has observed values on every row for that node label or edge
+  type.
+
+``optional``
+  The property has observed values on some rows and nulls on other rows for
+  that node label or edge type.
+
+``maybe_absent``
+  The column exists on the dataframe but has no observed value for that node
+  label or edge type. This commonly means another label/type uses the column.
+
+``unknown``
+  No rows were available for that node label or edge type.
+
+Declared Overrides
+------------------
+
+Declared schemas stay explicit. Passing ``schema=...`` to ``infer_schema()``
+uses declared node and edge definitions in preference to inferred definitions
+with the same names, while keeping inferred definitions for other names.
+
+.. code-block:: python
+
+   refined_schema = g.infer_schema(schema=schema)
+
+``g.bind(schema=..., infer_schema=True)`` is rejected. Use either a provided
+schema or inferred schema in a single bind call so the validation contract is
+unambiguous.
 
 Local vs. Remote GFQL
 ---------------------
diff --git a/graphistry/Plottable.py b/graphistry/Plottable.py
index 613891d05e..83563336d2 100644
--- a/graphistry/Plottable.py
+++ b/graphistry/Plottable.py
@@ -364,9 +364,13 @@ def bind(
         nodes_file_id: Optional[str] = None,
         edges_file_id: Optional[str] = None,
         schema: Optional[Any] = None,
+        infer_schema: Any = False,
     ) -> 'Plottable':
         ...
 
+    def infer_schema(self, *, schema: Optional[Any] = None, return_report: bool = False) -> Any:
+        ...
+
     def copy(self) -> 'Plottable':
         ...
 
diff --git a/graphistry/PlotterBase.py b/graphistry/PlotterBase.py
index d055675035..75ad1c1125 100644
--- a/graphistry/PlotterBase.py
+++ b/graphistry/PlotterBase.py
@@ -1622,6 +1622,7 @@ def bind(self,
             nodes_file_id: Optional[str] = None,
             edges_file_id: Optional[str] = None,
             schema: Optional[Any] = None,
+            infer_schema: Any = False,
         ) -> Plottable:
         """Relate data attributes to graph structure and visual representation. To facilitate reuse and replayable notebooks, the binding call is chainable. Invocation does not effect the old binding: it instead returns a new Plotter instance with the new bindings added to the existing ones. Both the old and new bindings can then be used for different graphs.
 
@@ -1694,6 +1695,9 @@ def bind(self,
         :param schema: Optional experimental public GFQL schema declaration from ``graphistry.schema``.
         :type schema: Optional[Any]
 
+        :param infer_schema: Infer an experimental public GFQL schema from currently bound data and attach it.
+        :type infer_schema: bool
+
         :returns: Plotter
         :rtype: Plotter
 
@@ -1773,7 +1777,16 @@ def bind(self,
         res._url = url or self._url
         res._nodes_file_id = nodes_file_id or self._nodes_file_id
         res._edges_file_id = edges_file_id or self._edges_file_id
-        res._gfql_schema = schema if schema is not None else self._gfql_schema
+        if schema is not None and infer_schema:
+            raise ValueError("schema and infer_schema cannot both be set")
+        if infer_schema and self._gfql_schema is not None:
+            raise ValueError("schema and infer_schema cannot both be set")
+        if infer_schema:
+            from graphistry.schema_inference import infer_schema as _infer_schema
+
+            res._gfql_schema = _infer_schema(res)
+        else:
+            res._gfql_schema = schema if schema is not None else self._gfql_schema
 
         # Invalidate dataset_id if we're changing encodings, not setting IDs
         encoding_params_changed = any([
@@ -1792,6 +1805,12 @@ def bind(self,
     def copy(self) -> Plottable:
         return copy.copy(self)
 
+    def infer_schema(self, *, schema: Optional[Any] = None, return_report: bool = False) -> Any:
+        """Infer an experimental public GFQL schema from currently bound data."""
+        from graphistry.schema_inference import infer_schema
+
+        return infer_schema(self, schema=schema, return_report=return_report)
+
 
     def nodes(self, nodes: Union[Callable, Any], node=None, *args, **kwargs) -> Plottable:
         """Specify the set of nodes and associated data.
diff --git a/graphistry/__init__.py b/graphistry/__init__.py
index 988cf0f10d..df06700972 100644
--- a/graphistry/__init__.py
+++ b/graphistry/__init__.py
@@ -42,6 +42,7 @@
     encode_point_badge,
     encode_edge_badge,
     apply_encodings,
+    infer_schema,
     hypergraph,
     bolt,
     cypher,
@@ -140,6 +141,12 @@
     NodeType,
 )
 
+from graphistry.schema_inference import (
+    InferredProperty,
+    PresenceState,
+    SchemaInferenceReport,
+)
+
 from graphistry.privacy import (
     Mode, Privacy
 )
diff --git a/graphistry/pygraphistry.py b/graphistry/pygraphistry.py
index 6416069369..d016c79551 100644
--- a/graphistry/pygraphistry.py
+++ b/graphistry/pygraphistry.py
@@ -1925,12 +1925,14 @@ def bind(
         nodes_file_id: Optional[str] = None,
         edges_file_id: Optional[str] = None,
         schema: Optional[Any] = None,
+        infer_schema: Any = False,
     ) -> Plotter:
         """Create a base plotter.
 
         Typically called at start of a program. For parameters, see ``plotter.bind()`` .
         The ``schema`` parameter accepts the experimental public GFQL schema
-        declarations from ``graphistry.schema``.
+        declarations from ``graphistry.schema``. ``infer_schema=True`` infers
+        that schema from currently bound local data.
 
         :returns: Plotter
         :rtype: Plotter
@@ -1974,8 +1976,17 @@ def bind(
             nodes_file_id=nodes_file_id,
             edges_file_id=edges_file_id,
             schema=schema,
+            infer_schema=infer_schema,
         ))
 
+    def infer_schema(self, g: Optional[Any] = None, *, schema: Optional[Any] = None, return_report: bool = False) -> Any:
+        """Infer an experimental public GFQL schema from a plotter."""
+        from graphistry.schema_inference import infer_schema
+
+        if g is None:
+            raise ValueError("graphistry.infer_schema(g) requires a plotter; use g.infer_schema() for bound graphs")
+        return infer_schema(g, schema=schema, return_report=return_report)
+
     def from_dataset_id(self, dataset_id: str, api_token: Optional[str] = None) -> Plotter:
         """Fetch existing remote dataset metadata and hydrate a Plotter.
 
@@ -2763,6 +2774,7 @@ def _handle_api_response(self, response):
 encode_point_badge = PyGraphistry.encode_point_badge
 encode_edge_badge = PyGraphistry.encode_edge_badge
 apply_encodings = PyGraphistry.apply_encodings
+infer_schema = PyGraphistry.infer_schema
 infer_labels = PyGraphistry.infer_labels
 name = PyGraphistry.name
 description = PyGraphistry.description
diff --git a/graphistry/schema.py b/graphistry/schema.py
index 203e08c771..2ce5736dc3 100644
--- a/graphistry/schema.py
+++ b/graphistry/schema.py
@@ -331,6 +331,7 @@ class GraphSchema:
     node_id_column: Optional[str] = None
     edge_source_column: Optional[str] = None
     edge_destination_column: Optional[str] = None
+    metadata: Mapping[str, Any] = field(default_factory=dict, compare=False)
 
     def __init__(
         self,
@@ -341,6 +342,7 @@ def __init__(
         node_id_column: Optional[str] = None,
         edge_source_column: Optional[str] = None,
         edge_destination_column: Optional[str] = None,
+        metadata: Optional[Mapping[str, Any]] = None,
     ) -> None:
         object.__setattr__(self, "node_types", tuple(node_types))
         object.__setattr__(self, "edge_types", tuple(edge_types))
@@ -348,6 +350,7 @@ def __init__(
         object.__setattr__(self, "node_id_column", node_id_column)
         object.__setattr__(self, "edge_source_column", edge_source_column)
         object.__setattr__(self, "edge_destination_column", edge_destination_column)
+        object.__setattr__(self, "metadata", dict(metadata or {}))
 
     @property
     def node_columns(self) -> FrozenSet[str]:
@@ -441,6 +444,7 @@ def to_arrow(
             "node_id_column": self.node_id_column,
             "edge_source_column": self.edge_source_column,
             "edge_destination_column": self.edge_destination_column,
+            "metadata": dict(self.metadata),
         }
 
     @classmethod
@@ -454,6 +458,7 @@ def from_arrow(
         node_id_column: Optional[str] = None,
         edge_source_column: Optional[str] = None,
         edge_destination_column: Optional[str] = None,
+        metadata: Optional[Mapping[str, Any]] = None,
         coercion: CoercionMode = "widen",
     ) -> "GraphSchema":
         """Import graph schema declarations from Arrow schemas.
@@ -471,6 +476,7 @@ def from_arrow(
                 Optional[str],
                 declaration.get("edge_destination_column", edge_destination_column),
             )
+            metadata = cast(Optional[Mapping[str, Any]], declaration.get("metadata", metadata))
 
         nodes = tuple(
             NodeType.from_arrow(name, schema, coercion=coercion)
@@ -487,6 +493,7 @@ def from_arrow(
             node_id_column=node_id_column,
             edge_source_column=edge_source_column,
             edge_destination_column=edge_destination_column,
+            metadata=metadata,
         )
 
     def to_catalog(
@@ -514,6 +521,7 @@ def to_catalog(
                 edge_type.name: edge_type.to_row_schema(include_type_label=False)
                 for edge_type in self.edge_types
             },
+            "schema_metadata": dict(self.metadata),
         }
         return GraphSchemaCatalog.from_schema_parts(
             node_columns=self.node_columns,
diff --git a/graphistry/schema_inference.py b/graphistry/schema_inference.py
new file mode 100644
index 0000000000..063d7b38df
--- /dev/null
+++ b/graphistry/schema_inference.py
@@ -0,0 +1,353 @@
+"""Experimental schema inference for public GFQL graph schemas."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, FrozenSet, Iterable, Literal, Mapping, Optional, Tuple, Union
+
+from graphistry.compute.gfql.ir.arrow_bridge import from_arrow
+from graphistry.compute.gfql.ir.logical_plan import RowSchema
+from graphistry.compute.gfql.ir.types import LogicalType, ScalarType
+from graphistry.schema import EdgeType, GraphSchema, NodeType
+
+
+PresenceState = Literal["required", "optional", "maybe_absent", "unknown"]
+
+_LABEL_PREFIX = "label__"
+_INFERENCE_METADATA_VERSION = 1
+
+
+@dataclass(frozen=True)
+class InferredProperty:
+    """Experimental per-property inference detail."""
+
+    logical_type: LogicalType
+    presence: PresenceState
+
+
+@dataclass(frozen=True)
+class SchemaInferenceReport:
+    """Experimental report for information not carried by ``GraphSchema``."""
+
+    node_properties: Mapping[str, Mapping[str, InferredProperty]] = field(default_factory=dict)
+    edge_properties: Mapping[str, Mapping[str, InferredProperty]] = field(default_factory=dict)
+
+
+def _inference_metadata(source: str) -> Dict[str, Any]:
+    return {
+        "source": source,
+        "inference": {
+            "version": _INFERENCE_METADATA_VERSION,
+            "label_column_prefix": _LABEL_PREFIX,
+            "node_label_source": "node-label-columns",
+            "edge_type_source": "edge-label-columns",
+            "property_type_source": "dataframe-arrow-schema",
+            "topology_source": "edge-endpoint-node-id-join",
+        },
+    }
+
+
+def _columns(df: Any) -> Tuple[str, ...]:
+    if df is None or not hasattr(df, "columns"):
+        return tuple()
+    return tuple(str(column) for column in df.columns)
+
+
+def _label_names(df: Any) -> Tuple[str, ...]:
+    return tuple(
+        sorted(
+            column[len(_LABEL_PREFIX):]
+            for column in _columns(df)
+            if column.startswith(_LABEL_PREFIX) and column[len(_LABEL_PREFIX):]
+        )
+    )
+
+
+def _label_column(label: str) -> str:
+    return f"{_LABEL_PREFIX}{label}"
+
+
+def _as_bool(value: Any) -> bool:
+    if hasattr(value, "item") and callable(getattr(value, "item")):
+        return bool(value.item())
+    return bool(value)
+
+
+def _truth_mask(df: Any, label: str) -> Any:
+    series = df[_label_column(label)]
+    try:
+        return (series == True).fillna(False)  # noqa: E712 - exact boolean label convention
+    except (TypeError, ValueError):
+        return series.fillna(False).astype("bool")
+
+
+def _select_rows(df: Any, mask: Any) -> Any:
+    return df.loc[mask]
+
+
+def _select_columns(df: Any, columns: Iterable[str]) -> Any:
+    selected = list(columns)
+    if not selected:
+        return df.iloc[:, 0:0]
+    return df[selected]
+
+
+def _series_has_nulls(series: Any) -> bool:
+    if len(series) == 0:
+        return True
+    return _as_bool(series.isna().any())
+
+
+def _series_has_values(series: Any) -> bool:
+    if len(series) == 0:
+        return False
+    return not _as_bool(series.isna().all())
+
+
+def _presence_for_series(series: Any) -> PresenceState:
+    if len(series) == 0:
+        return "unknown"
+    if not _series_has_values(series):
+        return "maybe_absent"
+    if _series_has_nulls(series):
+        return "optional"
+    return "required"
+
+
+def _to_arrow_schema(df: Any) -> Any:
+    try:
+        import pyarrow as pa
+    except ImportError as exc:
+        raise ImportError("pyarrow is required for graphistry.infer_schema()") from exc
+
+    if hasattr(df, "to_arrow") and callable(getattr(df, "to_arrow")):
+        try:
+            arrow_obj = df.to_arrow(preserve_index=False)
+        except TypeError:
+            arrow_obj = df.to_arrow()
+        return arrow_obj.schema
+    return pa.Table.from_pandas(df, preserve_index=False).schema
+
+
+def _row_schema_for_frame(df: Any, columns: Iterable[str]) -> RowSchema:
+    selected_columns = tuple(columns)
+    if not selected_columns:
+        return RowSchema()
+    row_schema, _ = from_arrow(_to_arrow_schema(_select_columns(df, selected_columns)))
+    adjusted: Dict[str, LogicalType] = {}
+    for column, logical_type in row_schema.columns.items():
+        if isinstance(logical_type, ScalarType):
+            adjusted[column] = ScalarType(logical_type.kind, nullable=_series_has_nulls(df[column]))
+        else:
+            adjusted[column] = logical_type
+    return RowSchema(columns=adjusted)
+
+
+def _property_schema_and_report(
+    df: Any,
+    *,
+    candidates: Iterable[str],
+) -> Tuple[Dict[str, LogicalType], Dict[str, InferredProperty]]:
+    schema_columns = []
+    report: Dict[str, InferredProperty] = {}
+    for column in sorted(candidates):
+        presence = _presence_for_series(df[column])
+        if presence in {"required", "optional"}:
+            schema_columns.append(column)
+
+    row_schema = _row_schema_for_frame(df, schema_columns)
+    for column in sorted(candidates):
+        logical_type = row_schema.columns.get(column, ScalarType("unknown"))
+        report[column] = InferredProperty(
+            logical_type=logical_type,
+            presence=_presence_for_series(df[column]),
+        )
+    return dict(row_schema.columns), report
+
+
+def _infer_node_types(nodes_df: Any) -> Tuple[Tuple[NodeType, ...], Dict[str, Mapping[str, InferredProperty]]]:
+    if nodes_df is None:
+        return tuple(), {}
+
+    label_columns = frozenset(_label_column(label) for label in _label_names(nodes_df))
+    candidate_columns = tuple(column for column in _columns(nodes_df) if column not in label_columns)
+
+    node_types = []
+    report: Dict[str, Mapping[str, InferredProperty]] = {}
+    for label in _label_names(nodes_df):
+        selected = _select_rows(nodes_df, _truth_mask(nodes_df, label))
+        properties, property_report = _property_schema_and_report(
+            selected,
+            candidates=candidate_columns,
+        )
+        node_types.append(NodeType(label, properties))
+        report[label] = property_report
+    return tuple(node_types), report
+
+
+def _series_to_values(series: Any) -> Tuple[Any, ...]:
+    if hasattr(series, "to_arrow") and callable(getattr(series, "to_arrow")):
+        return tuple(series.to_arrow().to_pylist())
+    if hasattr(series, "tolist") and callable(getattr(series, "tolist")):
+        return tuple(series.tolist())
+    return tuple(series)
+
+
+def _node_labels_by_id(nodes_df: Any, *, node_id_column: Optional[str]) -> Dict[Any, FrozenSet[str]]:
+    if nodes_df is None or node_id_column is None or node_id_column not in _columns(nodes_df):
+        return {}
+
+    out: Dict[Any, FrozenSet[str]] = {}
+    for label in _label_names(nodes_df):
+        selected = _select_rows(nodes_df, _truth_mask(nodes_df, label))
+        for node_id in _series_to_values(selected[node_id_column]):
+            out[node_id] = out.get(node_id, frozenset()) | frozenset((label,))
+    return out
+
+
+def _topology_labels(
+    edges_df: Any,
+    *,
+    mask: Any,
+    endpoint_column: Optional[str],
+    labels_by_id: Mapping[Any, FrozenSet[str]],
+) -> FrozenSet[str]:
+    if edges_df is None or endpoint_column is None or endpoint_column not in _columns(edges_df):
+        return frozenset()
+    labels: FrozenSet[str] = frozenset()
+    selected = _select_rows(edges_df, mask)
+    for node_id in _series_to_values(selected[endpoint_column]):
+        labels = labels | labels_by_id.get(node_id, frozenset())
+    return labels
+
+
+def _infer_edge_types(
+    edges_df: Any,
+    *,
+    nodes_df: Any,
+    node_id_column: Optional[str],
+    edge_source_column: Optional[str],
+    edge_destination_column: Optional[str],
+    edge_id_column: Optional[str],
+) -> Tuple[Tuple[EdgeType, ...], Dict[str, Mapping[str, InferredProperty]]]:
+    if edges_df is None:
+        return tuple(), {}
+
+    edge_label_columns = frozenset(_label_column(label) for label in _label_names(edges_df))
+    structural_columns = {
+        column
+        for column in (edge_source_column, edge_destination_column, edge_id_column)
+        if column is not None
+    }
+    candidate_columns = tuple(
+        column
+        for column in _columns(edges_df)
+        if column not in edge_label_columns and column not in structural_columns
+    )
+    labels_by_id = _node_labels_by_id(nodes_df, node_id_column=node_id_column)
+
+    edge_types = []
+    report: Dict[str, Mapping[str, InferredProperty]] = {}
+    for relationship_type in _label_names(edges_df):
+        mask = _truth_mask(edges_df, relationship_type)
+        selected = _select_rows(edges_df, mask)
+        properties, property_report = _property_schema_and_report(
+            selected,
+            candidates=candidate_columns,
+        )
+        edge_types.append(
+            EdgeType(
+                relationship_type,
+                source=_topology_labels(
+                    edges_df,
+                    mask=mask,
+                    endpoint_column=edge_source_column,
+                    labels_by_id=labels_by_id,
+                ),
+                destination=_topology_labels(
+                    edges_df,
+                    mask=mask,
+                    endpoint_column=edge_destination_column,
+                    labels_by_id=labels_by_id,
+                ),
+                properties=properties,
+            )
+        )
+        report[relationship_type] = property_report
+    return tuple(edge_types), report
+
+
+def _merge_declared_schema(inferred: GraphSchema, declared: Optional[GraphSchema]) -> GraphSchema:
+    if declared is None:
+        return inferred
+
+    declared_nodes = {node_type.name: node_type for node_type in declared.node_types}
+    declared_edges = {edge_type.name: edge_type for edge_type in declared.edge_types}
+    metadata = dict(declared.metadata)
+    metadata.update(_inference_metadata("mixed"))
+    node_types = tuple(declared_nodes.values()) + tuple(
+        node_type for node_type in inferred.node_types if node_type.name not in declared_nodes
+    )
+    edge_types = tuple(declared_edges.values()) + tuple(
+        edge_type for edge_type in inferred.edge_types if edge_type.name not in declared_edges
+    )
+    return GraphSchema(
+        node_types=node_types,
+        edge_types=edge_types,
+        strict=declared.strict,
+        node_id_column=declared.node_id_column or inferred.node_id_column,
+        edge_source_column=declared.edge_source_column or inferred.edge_source_column,
+        edge_destination_column=declared.edge_destination_column or inferred.edge_destination_column,
+        metadata=metadata,
+    )
+
+
+def infer_schema(
+    g: Any,
+    *,
+    schema: Optional[GraphSchema] = None,
+    return_report: bool = False,
+) -> Union[GraphSchema, Tuple[GraphSchema, SchemaInferenceReport]]:
+    """Infer an experimental public ``GraphSchema`` from bound graph data.
+
+    Inference is opt-in and returns the same public schema objects as declared
+    schemas. When ``schema`` is provided, its node/edge declarations override
+    inferred declarations with the same names.
+    """
+    nodes_df = getattr(g, "_nodes", None)
+    edges_df = getattr(g, "_edges", None)
+    node_id_column = getattr(g, "_node", None)
+    edge_source_column = getattr(g, "_source", None)
+    edge_destination_column = getattr(g, "_destination", None)
+    edge_id_column = getattr(g, "_edge", None)
+
+    node_types, node_report = _infer_node_types(nodes_df)
+    edge_types, edge_report = _infer_edge_types(
+        edges_df,
+        nodes_df=nodes_df,
+        node_id_column=node_id_column,
+        edge_source_column=edge_source_column,
+        edge_destination_column=edge_destination_column,
+        edge_id_column=edge_id_column,
+    )
+    inferred = GraphSchema(
+        node_types=node_types,
+        edge_types=edge_types,
+        node_id_column=node_id_column,
+        edge_source_column=edge_source_column,
+        edge_destination_column=edge_destination_column,
+        metadata=_inference_metadata("inferred"),
+    )
+    merged = _merge_declared_schema(inferred, schema)
+    report = SchemaInferenceReport(
+        node_properties=node_report,
+        edge_properties=edge_report,
+    )
+    return (merged, report) if return_report else merged
+
+
+__all__ = [
+    "InferredProperty",
+    "PresenceState",
+    "SchemaInferenceReport",
+    "infer_schema",
+]
diff --git a/graphistry/tests/compute/gfql/test_public_schema.py b/graphistry/tests/compute/gfql/test_public_schema.py
index 163ab90877..45b476434a 100644
--- a/graphistry/tests/compute/gfql/test_public_schema.py
+++ b/graphistry/tests/compute/gfql/test_public_schema.py
@@ -164,7 +164,15 @@ def test_node_and_edge_types_round_trip_from_arrow() -> None:
 def test_graph_schema_arrow_declaration_round_trip() -> None:
     pa = pytest.importorskip("pyarrow")
 
-    schema = _schema(strict=False)
+    schema = GraphSchema(
+        node_types=_schema(strict=False).node_types,
+        edge_types=_schema(strict=False).edge_types,
+        strict=False,
+        node_id_column="id",
+        edge_source_column="src",
+        edge_destination_column="dst",
+        metadata={"source": "declared", "owner": "unit-test"},
+    )
     declaration = schema.to_arrow()
 
     assert declaration["nodes"].field("age").type == pa.int64()
@@ -173,6 +181,7 @@ def test_graph_schema_arrow_declaration_round_trip() -> None:
     assert declaration["edges"].metadata[b"gfql.arrow_bridge.version"] == b"1"
     assert declaration["edge_types"]["WORKS_AT"]["source"] == ("Person",)
     assert declaration["edge_types"]["WORKS_AT"]["destination"] == ("Company",)
+    assert declaration["metadata"] == {"source": "declared", "owner": "unit-test"}
 
     imported = GraphSchema.from_arrow(declaration)
 
@@ -180,11 +189,23 @@ def test_graph_schema_arrow_declaration_round_trip() -> None:
     assert imported.node_id_column == "id"
     assert imported.edge_source_column == "src"
     assert imported.edge_destination_column == "dst"
+    assert imported.metadata == {"source": "declared", "owner": "unit-test"}
     assert imported.node_columns == schema.node_columns
     assert imported.edge_columns == schema.edge_columns
     assert imported.edge_types[0].topology.as_metadata() == schema.edge_types[0].topology.as_metadata()
 
 
+def test_graph_schema_metadata_is_cataloged_but_not_validation_contract() -> None:
+    schema = GraphSchema(
+        node_types=_schema().node_types,
+        edge_types=_schema().edge_types,
+        metadata={"source": "inferred"},
+    )
+
+    assert schema == GraphSchema(node_types=_schema().node_types, edge_types=_schema().edge_types)
+    assert schema.to_catalog().metadata["schema_metadata"] == {"source": "inferred"}
+
+
 def test_bind_schema_is_chainable_and_used_by_preflight() -> None:
     schema = _schema()
     g = _graph(schema).bind(point_color="name")
diff --git a/graphistry/tests/compute/gfql/test_schema_inference.py b/graphistry/tests/compute/gfql/test_schema_inference.py
new file mode 100644
index 0000000000..25af3747e2
--- /dev/null
+++ b/graphistry/tests/compute/gfql/test_schema_inference.py
@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import pandas as pd
+import pytest
+
+import graphistry
+from graphistry.compute.exceptions import ErrorCode, GFQLValidationError
+from graphistry.compute.gfql.ir.types import ScalarType
+from graphistry.schema import EdgeType, GraphSchema, NodeType
+from graphistry.schema_inference import InferredProperty, SchemaInferenceReport
+
+
+def _person_company_graph():
+    nodes = pd.DataFrame(
+        [
+            {
+                "id": 1,
+                "name": "alice",
+                "age": 42,
+                "department": None,
+                "label__Person": True,
+                "label__Company": False,
+            },
+            {
+                "id": 2,
+                "name": "acme",
+                "age": None,
+                "department": "engineering",
+                "label__Person": False,
+                "label__Company": True,
+            },
+            {
+                "id": 3,
+                "name": "bob",
+                "age": None,
+                "department": None,
+                "label__Person": True,
+                "label__Company": False,
+            },
+        ]
+    )
+    edges = pd.DataFrame(
+        [
+            {"src": 1, "dst": 2, "since": 2020, "label__WORKS_AT": True},
+            {"src": 3, "dst": 2, "since": 2021, "label__WORKS_AT": True},
+        ]
+    )
+    return graphistry.bind(source="src", destination="dst", node="id").edges(edges).nodes(nodes)
+
+
+def _node_type(schema: GraphSchema, name: str) -> NodeType:
+    return next(node_type for node_type in schema.node_types if node_type.name == name)
+
+
+def _edge_type(schema: GraphSchema, name: str) -> EdgeType:
+    return next(edge_type for edge_type in schema.edge_types if edge_type.name == name)
+
+
+def test_infer_schema_public_function_returns_graph_schema() -> None:
+    schema = graphistry.infer_schema(_person_company_graph())
+
+    assert isinstance(schema, GraphSchema)
+    assert graphistry.InferredProperty is InferredProperty
+    assert graphistry.SchemaInferenceReport is SchemaInferenceReport
+    assert schema.metadata["source"] == "inferred"
+    assert schema.metadata["inference"]["label_column_prefix"] == "label__"
+    assert {node_type.name for node_type in schema.node_types} == {"Company", "Person"}
+    assert {edge_type.name for edge_type in schema.edge_types} == {"WORKS_AT"}
+
+
+def test_plotter_infer_schema_is_pure_and_chainable() -> None:
+    g = _person_company_graph()
+
+    schema = g.infer_schema()
+    rebound = g.bind(schema=schema)
+
+    assert getattr(g, "_gfql_schema", None) is None
+    assert rebound._gfql_schema is schema
+
+
+def test_module_infer_schema_requires_plotter() -> None:
+    with pytest.raises(ValueError, match="requires a plotter"):
+        graphistry.infer_schema()
+
+
+def test_bind_infer_schema_is_opt_in_and_round_trips_into_preflight() -> None:
+    g = _person_company_graph()
+
+    inferred = g.bind(infer_schema=True)
+
+    assert isinstance(inferred._gfql_schema, GraphSchema)
+    assert inferred.gfql_validate("MATCH (p:Person)-[:WORKS_AT]->(c:Company) RETURN p.name")["ok"] is True
+    with pytest.raises(GFQLValidationError) as exc_info:
+        inferred.gfql_validate("MATCH (p:Person)-[:WORKS_AT]->(x:Person) RETURN p.name")
+
+    err = exc_info.value
+    assert err.code == ErrorCode.E301
+    assert err.context["relationship_types"] == ("WORKS_AT",)
+
+
+def test_infer_node_and_edge_property_types_from_pandas() -> None:
+    schema = graphistry.infer_schema(_person_company_graph())
+    person = _node_type(schema, "Person")
+    works_at = _edge_type(schema, "WORKS_AT")
+
+    assert person.properties["id"] == ScalarType("int64", nullable=False)
+    assert person.properties["name"] == ScalarType("string", nullable=False)
+    assert person.properties["age"] == ScalarType("float64", nullable=True)
+    assert works_at.properties["since"] == ScalarType("int64", nullable=False)
+    assert "src" not in works_at.properties
+    assert "dst" not in works_at.properties
+
+
+def test_infer_presence_report_distinguishes_required_optional_and_maybe_absent() -> None:
+    _, report = graphistry.infer_schema(_person_company_graph(), return_report=True)
+
+    assert report.node_properties["Person"]["name"].presence == "required"
+    assert report.node_properties["Person"]["age"].presence == "optional"
+    assert report.node_properties["Person"]["department"].presence == "maybe_absent"
+    assert report.edge_properties["WORKS_AT"]["since"].presence == "required"
+
+
+def test_infer_relationship_topology_from_endpoint_labels() -> None:
+    schema = graphistry.infer_schema(_person_company_graph())
+    works_at = _edge_type(schema, "WORKS_AT")
+
+    assert works_at.source == frozenset({"Person"})
+    assert works_at.destination == frozenset({"Company"})
+
+
+def test_infer_edge_only_graph_keeps_edge_schema_without_fabricating_topology() -> None:
+    g = graphistry.bind(source="src", destination="dst").edges(
+        pd.DataFrame({"src": [1], "dst": [2], "weight": [0.5], "label__KNOWS": [True]})
+    )
+
+    schema = graphistry.infer_schema(g)
+    knows = _edge_type(schema, "KNOWS")
+
+    assert schema.node_types == ()
+    assert knows.properties["weight"] == ScalarType("float64", nullable=False)
+    assert knows.source == frozenset()
+    assert knows.destination == frozenset()
+
+
+def test_infer_schema_no_data_fallback_is_empty_bound_schema() -> None:
+    schema = graphistry.bind(source="src", destination="dst", node="id").infer_schema()
+
+    assert schema == GraphSchema(
+        node_id_column="id",
+        edge_source_column="src",
+        edge_destination_column="dst",
+    )
+    assert schema.metadata["source"] == "inferred"
+
+
+def test_declared_schema_is_not_silently_merged_by_bind_infer_schema() -> None:
+    declared = GraphSchema(node_types=[NodeType("Declared", {"name": str})])
+    g = _person_company_graph().bind(schema=declared)
+
+    with pytest.raises(ValueError, match="schema and infer_schema"):
+        g.bind(infer_schema=True)
+
+    assert g.bind()._gfql_schema is declared
+
+
+def test_infer_schema_declared_override_wins_when_requested() -> None:
+    declared = GraphSchema(
+        node_types=[NodeType("Person", {"age": "string"})],
+        edge_types=[EdgeType("WORKS_AT", source="Person", destination="Company", properties={"since": "float64"})],
+    )
+
+    schema = graphistry.infer_schema(_person_company_graph(), schema=declared)
+
+    assert schema.metadata["source"] == "mixed"
+    assert schema.metadata["inference"]["property_type_source"] == "dataframe-arrow-schema"
+    assert _node_type(schema, "Person").properties["age"] == ScalarType("string")
+    assert _edge_type(schema, "WORKS_AT").properties["since"] == ScalarType("float64")
+    assert _node_type(schema, "Company").properties["name"] == ScalarType("string", nullable=False)
+
+
+def test_infer_schema_cudf_matches_pandas_representative_case() -> None:
+    cudf = pytest.importorskip("cudf")
+    cp = pytest.importorskip("cupy")
+    try:
+        device_count = cp.cuda.runtime.getDeviceCount()
+    except cp.cuda.runtime.CUDARuntimeError as exc:
+        pytest.skip(f"cuDF schema inference requires a CUDA device: {exc}")
+    if device_count == 0:
+        pytest.skip("cuDF schema inference requires a CUDA device")
+
+    pdf_graph = _person_company_graph()
+    gdf_graph = graphistry.bind(source="src", destination="dst", node="id").edges(
+        cudf.from_pandas(pdf_graph._edges)
+    ).nodes(
+        cudf.from_pandas(pdf_graph._nodes)
+    )
+
+    assert graphistry.infer_schema(gdf_graph) == graphistry.infer_schema(pdf_graph)