diff --git a/src/autogluon/cloud/endpoint/tabular_endpoint.py b/src/autogluon/cloud/endpoint/tabular_endpoint.py
new file mode 100644
index 00000000..0b570598
--- /dev/null
+++ b/src/autogluon/cloud/endpoint/tabular_endpoint.py
@@ -0,0 +1,84 @@
+from pathlib import Path
+from typing import Any, Dict, Union
+
+import pandas as pd
+
+from autogluon.common.loaders import load_pd
+
+from ..utils.serializers import AutoGluonSerializationWrapper
+from ..utils.utils import split_pred_and_pred_proba
+from .endpoint import Endpoint
+
+
+class TabularEndpoint:
+    """High-level endpoint for tabular foundation-model prediction.
+
+    Each request carries both the labeled few-shot context (``train_data``) and the unlabeled
+    rows to predict on (``test_data``); the endpoint fits a fresh predictor per request.
+    """
+
+    def __init__(self, endpoint: Endpoint):
+        self._endpoint = endpoint
+
+    @property
+    def endpoint_name(self) -> str:
+        return self._endpoint.endpoint_name
+
+    def predict(
+        self,
+        train_data: Union[str, Path, pd.DataFrame],
+        test_data: Union[str, Path, pd.DataFrame],
+        label: str = "target",
+        accept: str = "application/x-parquet",
+    ) -> pd.Series:
+        """Run real-time prediction. Returns the predicted label column."""
+        result = self._invoke(train_data, test_data, label=label, accept=accept)
+        if result.shape[1] == 1:
+            return result.iloc[:, 0]
+        pred, _ = split_pred_and_pred_proba(result)
+        return pred
+
+    def predict_proba(
+        self,
+        train_data: Union[str, Path, pd.DataFrame],
+        test_data: Union[str, Path, pd.DataFrame],
+        label: str = "target",
+        include_predict: bool = False,
+        accept: str = "application/x-parquet",
+    ) -> Union[pd.DataFrame, "tuple"]:
+        """Run real-time prediction. Returns class probabilities (classification only).
+
+        If ``include_predict`` is True, returns ``(prediction, predict_probability)``.
+        """
+        result = self._invoke(train_data, test_data, label=label, accept=accept)
+        if result.shape[1] == 1:
+            raise ValueError(
+                "predict_proba is not supported for regression endpoints — only a single column was returned."
+            )
+        pred, pred_proba = split_pred_and_pred_proba(result)
+        if include_predict:
+            return pred, pred_proba
+        return pred_proba
+
+    def _invoke(
+        self,
+        train_data: Union[str, Path, pd.DataFrame],
+        test_data: Union[str, Path, pd.DataFrame],
+        *,
+        label: str,
+        accept: str,
+    ) -> pd.DataFrame:
+        train_df = load_pd.load(str(train_data)) if not isinstance(train_data, pd.DataFrame) else train_data
+        test_df = load_pd.load(str(test_data)) if not isinstance(test_data, pd.DataFrame) else test_data
+
+        inference_kwargs: Dict[str, Any] = {"label": label}
+        payload = AutoGluonSerializationWrapper(
+            data=test_df,
+            inference_kwargs=inference_kwargs,
+            train_data=train_df,
+        )
+        return self._endpoint.predict(payload, initial_args={"Accept": accept})
+
+    def delete_endpoint(self) -> None:
+        """Delete the endpoint and cleanup artifacts."""
+        self._endpoint.delete_endpoint()
diff --git a/src/autogluon/cloud/model/foundation_model.py b/src/autogluon/cloud/model/foundation_model.py
index 2f384ff6..5ffe9485 100644
--- a/src/autogluon/cloud/model/foundation_model.py
+++ b/src/autogluon/cloud/model/foundation_model.py
@@ -11,6 +11,7 @@
 
 from ..backend.backend_factory import BackendFactory
 from ..backend.constant import SAGEMAKER, TABULAR_SAGEMAKER, TIMESERIES_SAGEMAKER
+from ..endpoint.tabular_endpoint import TabularEndpoint
 from ..endpoint.timeseries_endpoint import TimeSeriesEndpoint
 from ..scripts.script_manager import ScriptManager
 from ..utils.aws_utils import resolve_cloud_output_path
@@ -431,100 +432,202 @@ class TabularFoundationModel(FoundationModel):
 
     @property
     def _serve_script_path(self) -> str:
-        raise NotImplementedError("Tabular FM deploy is not yet supported")
-
-    def deploy(self, **kwargs):
-        raise NotImplementedError("Tabular FM deploy is not yet supported")
+        return ScriptManager.SAGEMAKER_TABULAR_FM_SERVE_SCRIPT_PATH
 
     def _build_predictor_init_args(self, label: str = "target", **kwargs) -> Dict[str, Any]:
         """Map user kwargs to TabularPredictor init args."""
         return {"label": label}
 
-    def predict(
+    def _build_predictor_fit_args(self, hyperparameters: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        model_name = self._config["model_name"]
+        merged_hp = self._get_hyperparameters("inference", hyperparameters)
+        return {
+            "hyperparameters": {model_name: merged_hp},
+            "fit_weighted_ensemble": False,
+            "calibrate_decision_threshold": False,
+        }
+
+    def deploy(
         self,
-        train_data: Union[str, Path, pd.DataFrame],
-        test_data: Union[str, Path, pd.DataFrame],
-        label: str = "target",
-        hyperparameters: Optional[Dict[str, Any]] = None,
         instance_type: Optional[str] = None,
+        endpoint_name: Optional[str] = None,
+        hyperparameters: Optional[Dict[str, Any]] = None,
         framework_version: str = "latest",
         custom_image_uri: Optional[str] = None,
         wait: bool = True,
         **backend_kwargs,
-    ) -> Optional[pd.DataFrame]:
+    ) -> TabularEndpoint:
         """
-        Run batch prediction for tabular tasks.
-
-        For tabular foundation models (e.g., Mitra), train_data provides the few-shot
-        context and test_data contains the rows to predict on.
+        Deploy the foundation model to a real-time endpoint.
 
         Parameters
         ----------
-        train_data
-            Labeled few-shot context for the foundation model.
-        test_data
-            Unlabeled data to predict on.
-        label
-            Target column name in train_data.
-        hyperparameters
-            Model hyperparameters for inference. Overrides values passed to the constructor.
         instance_type
-            Instance type for the prediction job. If None, uses registry default.
+            Instance type for the endpoint. If None, uses registry default.
+        endpoint_name
+            Custom endpoint name. If None, auto-generated.
+        hyperparameters
+            Model hyperparameters for inference. Overrides constructor values.
         framework_version
             Container framework version.
         custom_image_uri
-            Custom Docker image URI for the container.
+            Custom Docker image URI for the inference container.
         wait
-            If True, block and return DataFrame. If False, return the job handle.
+            Whether to block until the endpoint is ready.
         **backend_kwargs
-            Additional backend-specific arguments.
+            Backend-specific arguments.
 
         Returns
         -------
-        Optional[pd.DataFrame]
+        TabularEndpoint
         """
-        # TODO: requires fit_predict support for TabularCloudPredictor
-        raise NotImplementedError
+        self._deploy_backend(
+            instance_type=instance_type,
+            endpoint_name=endpoint_name,
+            hyperparameters=hyperparameters,
+            framework_version=framework_version,
+            custom_image_uri=custom_image_uri,
+            wait=wait,
+            **backend_kwargs,
+        )
+        return TabularEndpoint(self._backend.endpoint)
 
-    def predict_proba(
+    def _run_fit_predict_job(
+        self,
+        train_data: Union[str, Path, pd.DataFrame],
+        test_data: Union[str, Path, pd.DataFrame],
+        *,
+        label: str,
+        hyperparameters: Optional[Dict[str, Any]],
+        instance_type: Optional[str],
+        framework_version: str,
+        custom_image_uri: Optional[str],
+        wait: bool,
+        predictions_path: Optional[str],
+        **backend_kwargs,
+    ) -> Optional[pd.DataFrame]:
+        """Launch a single fit+predict SageMaker job.
+
+        For classification tasks the job emits a combined DataFrame ``[<label>, <class>_proba, ...]``
+        so :meth:`predict` and :meth:`predict_proba` can share one job. For regression it emits the
+        single-column predictions DataFrame.
+        """
+        if instance_type is None:
+            instance_type = self._config["predict_instance_type"]
+
+        predictor_init_args = self._build_predictor_init_args(label=label)
+        predictor_fit_args = self._build_predictor_fit_args(hyperparameters)
+        data_channels = {
+            "train_data": train_data,
+            "test_data": test_data,
+        }
+
+        extra_ag_args: Dict[str, Any] = {"predict_after_fit": True}
+        if predictions_path is not None:
+            extra_ag_args["predictions_path"] = predictions_path
+
+        self._backend.fit(
+            predictor_init_args=predictor_init_args,
+            predictor_fit_args=predictor_fit_args,
+            data_channels=data_channels,
+            framework_version=framework_version,
+            instance_type=instance_type,
+            custom_image_uri=custom_image_uri,
+            wait=wait,
+            extra_ag_args=extra_ag_args,
+            **backend_kwargs,
+        )
+
+        if not wait:
+            return None
+
+        return self._backend.get_fit_predict_results()
+
+    def predict(
         self,
         train_data: Union[str, Path, pd.DataFrame],
         test_data: Union[str, Path, pd.DataFrame],
         label: str = "target",
         hyperparameters: Optional[Dict[str, Any]] = None,
-        output_path: Optional[str] = None,
         instance_type: Optional[str] = None,
+        framework_version: str = "latest",
+        custom_image_uri: Optional[str] = None,
         wait: bool = True,
+        predictions_path: Optional[str] = None,
         **backend_kwargs,
-    ) -> Optional[pd.DataFrame]:
+    ) -> Optional[pd.Series]:
         """
-        Run batch prediction returning class probabilities.
+        Run batch prediction for tabular tasks.
 
-        Parameters
-        ----------
-        train_data
-            Labeled few-shot context for the foundation model.
-        test_data
-            Unlabeled data to predict on.
-        label
-            Target column name in train_data.
-        hyperparameters
-            Model hyperparameters for inference. Overrides values passed to the constructor.
-            Available hyperparameters for each model are listed in the AutoGluon documentation.
-        output_path
-            S3 path to store predictions.
-            If None, will auto-generate under cloud_output_path.
-        instance_type
-            Instance type for the prediction job.
-            If None, will use the default from the model registry.
-        wait
-            If True, block and return DataFrame. If False, return the job handle.
-        **backend_kwargs
-            Additional backend-specific arguments (e.g. job_name, custom_image_uri,
-            framework_version, volume_size).
+        For tabular foundation models (e.g., Mitra), ``train_data`` provides the few-shot context
+        and ``test_data`` contains the rows to predict on. Both are uploaded to a single SageMaker
+        training job that runs the in-context-learning fit and prediction in one pass.
 
         Returns
         -------
-        Optional[pd.DataFrame]
+        Optional[pd.Series]
+            Predicted labels (``None`` when ``wait`` is False).
         """
-        raise NotImplementedError
+        from ..utils.utils import split_pred_and_pred_proba
+
+        result = self._run_fit_predict_job(
+            train_data=train_data,
+            test_data=test_data,
+            label=label,
+            hyperparameters=hyperparameters,
+            instance_type=instance_type,
+            framework_version=framework_version,
+            custom_image_uri=custom_image_uri,
+            wait=wait,
+            predictions_path=predictions_path,
+            **backend_kwargs,
+        )
+        if result is None:
+            return None
+        if self._config["task"] == "regression":
+            return result.iloc[:, 0]
+        pred, _ = split_pred_and_pred_proba(result)
+        return pred
+
+    def predict_proba(
+        self,
+        train_data: Union[str, Path, pd.DataFrame],
+        test_data: Union[str, Path, pd.DataFrame],
+        label: str = "target",
+        include_predict: bool = False,
+        hyperparameters: Optional[Dict[str, Any]] = None,
+        instance_type: Optional[str] = None,
+        framework_version: str = "latest",
+        custom_image_uri: Optional[str] = None,
+        wait: bool = True,
+        predictions_path: Optional[str] = None,
+        **backend_kwargs,
+    ) -> Optional[Union[pd.DataFrame, "tuple"]]:
+        """
+        Run batch prediction returning class probabilities. Only valid for classification tasks.
+
+        Parameters mirror :meth:`predict`. If ``include_predict`` is True, returns a tuple of
+        ``(prediction, predict_probability)``; otherwise returns ``predict_probability`` only.
+        """
+        from ..utils.utils import split_pred_and_pred_proba
+
+        if self._config["task"] != "classification":
+            raise ValueError(f"predict_proba is only supported for classification, got task='{self._config['task']}'.")
+        result = self._run_fit_predict_job(
+            train_data=train_data,
+            test_data=test_data,
+            label=label,
+            hyperparameters=hyperparameters,
+            instance_type=instance_type,
+            framework_version=framework_version,
+            custom_image_uri=custom_image_uri,
+            wait=wait,
+            predictions_path=predictions_path,
+            **backend_kwargs,
+        )
+        if result is None:
+            return None
+        pred, pred_proba = split_pred_and_pred_proba(result)
+        if include_predict:
+            return pred, pred_proba
+        return pred_proba
diff --git a/src/autogluon/cloud/model/registry.py b/src/autogluon/cloud/model/registry.py
index 2703bd3a..7714c86f 100644
--- a/src/autogluon/cloud/model/registry.py
+++ b/src/autogluon/cloud/model/registry.py
@@ -58,23 +58,32 @@ class FoundationModelConfig(TypedDict):
         "fit_instance_type": "ml.g5.xlarge",
         "fine_tunable": True,
     },
-    # TODO: Replace dummy configs with real values
     "mitra-classification": {
         "task": "classification",
-        "model_name": "Mitra",
-        "inference_hyperparameters": {"model_path": "TODO"},
-        "training_hyperparameters": {"model_path": "TODO"},
-        "predict_instance_type": "ml.m5.2xlarge",
+        "model_name": "MITRA",
+        "inference_hyperparameters": {"fine_tune": False},
+        "training_hyperparameters": {"fine_tune": True},
+        "predict_instance_type": "ml.g5.xlarge",
         "deploy_instance_type": "ml.g5.xlarge",
         "fit_instance_type": "ml.g5.xlarge",
-        "fine_tunable": False,
+        "fine_tunable": True,
     },
     "mitra-regression": {
         "task": "regression",
-        "model_name": "Mitra",
-        "inference_hyperparameters": {"model_path": "TODO"},
-        "training_hyperparameters": {"model_path": "TODO"},
-        "predict_instance_type": "ml.m5.2xlarge",
+        "model_name": "MITRA",
+        "inference_hyperparameters": {"fine_tune": False},
+        "training_hyperparameters": {"fine_tune": True},
+        "predict_instance_type": "ml.g5.xlarge",
+        "deploy_instance_type": "ml.g5.xlarge",
+        "fit_instance_type": "ml.g5.xlarge",
+        "fine_tunable": True,
+    },
+    "tabicl": {
+        "task": "classification",
+        "model_name": "TABICL",
+        "inference_hyperparameters": {},
+        "training_hyperparameters": {},
+        "predict_instance_type": "ml.g5.xlarge",
         "deploy_instance_type": "ml.g5.xlarge",
         "fit_instance_type": "ml.g5.xlarge",
         "fine_tunable": False,
diff --git a/src/autogluon/cloud/predictor/cloud_predictor.py b/src/autogluon/cloud/predictor/cloud_predictor.py
index cca40479..71cf9892 100644
--- a/src/autogluon/cloud/predictor/cloud_predictor.py
+++ b/src/autogluon/cloud/predictor/cloud_predictor.py
@@ -765,6 +765,10 @@ def cleanup_deployment(self) -> None:
         """
         self.backend.cleanup_deployment()
 
+    def get_fit_predict_results(self) -> pd.DataFrame:
+        """Retrieve predictions produced by a completed ``fit_predict`` job."""
+        return self.backend.get_fit_predict_results()
+
     def _download_predictor(self, path, save_path):
         logger.log(20, "Downloading trained models to local directory")
         predictor_bucket, predictor_key_prefix = s3_path_to_bucket_prefix(path)
diff --git a/src/autogluon/cloud/predictor/tabular_cloud_predictor.py b/src/autogluon/cloud/predictor/tabular_cloud_predictor.py
index 456547ae..5514c4ea 100644
--- a/src/autogluon/cloud/predictor/tabular_cloud_predictor.py
+++ b/src/autogluon/cloud/predictor/tabular_cloud_predictor.py
@@ -1,4 +1,10 @@
+from __future__ import annotations
+
 import logging
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+import pandas as pd
 
 from ..backend.constant import RAY_AWS, SAGEMAKER, TABULAR_RAY_AWS, TABULAR_SAGEMAKER
 from .cloud_predictor import CloudPredictor
@@ -28,3 +34,99 @@ def _get_local_predictor_cls(self):
 
         predictor_cls = TabularPredictor
         return predictor_cls
+
+    def fit_predict(
+        self,
+        train_data: Union[str, Path, pd.DataFrame],
+        test_data: Union[str, Path, pd.DataFrame],
+        *,
+        predictor_init_args: Dict[str, Any],
+        predictor_fit_args: Optional[Dict[str, Any]] = None,
+        framework_version: str = "latest",
+        job_name: Optional[str] = None,
+        instance_type: str = "ml.m5.2xlarge",
+        instance_count: int = 1,
+        volume_size: int = 256,
+        custom_image_uri: Optional[str] = None,
+        timeout: int = 24 * 60 * 60,
+        wait: bool = True,
+        predictions_path: Optional[str] = None,
+        backend_kwargs: Optional[Dict] = None,
+    ) -> Optional[pd.DataFrame]:
+        """
+        Fit and predict in a single SageMaker training job.
+
+        This is useful for tabular foundation-model workflows (e.g. Mitra) where "fit" is essentially
+        loading a pretrained model. Running fit and predict in the same job avoids the SageMaker
+        startup overhead twice.
+
+        For classification tasks, the returned DataFrame matches the output of
+        :meth:`TabularCloudPredictor.predict_proba` with ``include_predict=True`` — the first
+        column is the predicted class and the remaining columns are class probabilities (suffixed
+        ``_proba``). Use :func:`autogluon.cloud.utils.utils.split_pred_and_pred_proba` to split.
+
+        Parameters
+        ----------
+        train_data: Union[str, pathlib.Path, pd.DataFrame]
+            Labeled training data, as a DataFrame or local/S3 path to a data file.
+        test_data: Union[str, pathlib.Path, pd.DataFrame]
+            Unlabeled data to predict on, as a DataFrame or local/S3 path to a data file.
+        predictor_init_args: dict
+            Arguments forwarded to ``TabularPredictor()`` (must include ``label``).
+        predictor_fit_args: Optional[dict], default = None
+            Additional fit args forwarded to ``TabularPredictor.fit()``.
+        predictions_path: Optional[str]
+            S3 URL where predictions will be written by the training container. Defaults to
+            ``{cloud_output_path}/{job_name}/predictions.csv``. Must end in ``.csv`` or ``.parquet``.
+        framework_version, job_name, instance_type, instance_count, volume_size, custom_image_uri,
+        timeout, wait, backend_kwargs:
+            Same semantics as ``fit()``.
+
+        Returns
+        -------
+        Optional[pd.DataFrame]
+            Predictions as a DataFrame. Returns ``None`` when ``wait`` is False.
+        """
+        assert not self.backend.is_fit, (
+            "Predictor is already fit! To fit additional models, create a new `CloudPredictor`"
+        )
+        if backend_kwargs is None:
+            backend_kwargs = {}
+        else:
+            backend_kwargs = dict(backend_kwargs)
+
+        extra_ag_args: Dict[str, Any] = {"predict_after_fit": True}
+        if predictions_path is not None:
+            extra_ag_args["predictions_path"] = predictions_path
+        backend_kwargs["extra_ag_args"] = extra_ag_args
+
+        predictor_fit_args = {} if predictor_fit_args is None else dict(predictor_fit_args)
+        data_channels = {
+            "train_data": train_data,
+            "test_data": test_data,
+        }
+
+        backend_kwargs = self.backend.parse_backend_fit_kwargs(backend_kwargs)
+        self.backend.fit(
+            predictor_init_args=predictor_init_args,
+            predictor_fit_args=predictor_fit_args,
+            data_channels=data_channels,
+            framework_version=framework_version,
+            job_name=job_name,
+            instance_type=instance_type,
+            instance_count=instance_count,
+            volume_size=volume_size,
+            custom_image_uri=custom_image_uri,
+            timeout=timeout,
+            wait=wait,
+            **backend_kwargs,
+        )
+
+        if not wait:
+            logger.info(
+                "fit_predict job launched asynchronously. Use `get_fit_job_status()` "
+                "to poll, then `get_fit_predict_results()` to fetch predictions."
+            )
+            return None
+
+        return self.get_fit_predict_results()
diff --git a/src/autogluon/cloud/predictor/timeseries_cloud_predictor.py b/src/autogluon/cloud/predictor/timeseries_cloud_predictor.py
index 3afad3b7..e6271c01 100644
--- a/src/autogluon/cloud/predictor/timeseries_cloud_predictor.py
+++ b/src/autogluon/cloud/predictor/timeseries_cloud_predictor.py
@@ -424,14 +424,3 @@ def fit_predict(
             return None
 
         return self.get_fit_predict_results()
-
-    def get_fit_predict_results(self) -> pd.DataFrame:
-        """
-        Retrieve predictions produced by a completed ``fit_predict`` job.
-
-        Returns
-        -------
-        pd.DataFrame
-            Predictions for the forecast horizon.
-        """
-        return self.backend.get_fit_predict_results()
diff --git a/src/autogluon/cloud/scripts/sagemaker_scripts/serving_utils/tabular.py b/src/autogluon/cloud/scripts/sagemaker_scripts/serving_utils/tabular.py
new file mode 100644
index 00000000..268894eb
--- /dev/null
+++ b/src/autogluon/cloud/scripts/sagemaker_scripts/serving_utils/tabular.py
@@ -0,0 +1,59 @@
+"""Serde helpers used by the tabular foundation-model serve script."""
+
+import base64
+import json
+from io import BytesIO
+from typing import Any, Dict, Optional, Tuple
+
+import pandas as pd
+
+ParsedPayload = Tuple[pd.DataFrame, pd.DataFrame, Dict[str, Any]]
+
+
+def parse_payload(request_body, content_type: str) -> ParsedPayload:
+    """Parse a request body into ``(train_data, test_data, inference_kwargs)``.
+
+    Tabular foundation models need both the few-shot context (``train_data``) and the rows
+    to predict on (``test_data``) on every request.
+    """
+    if isinstance(request_body, str):
+        request_body = request_body.encode()
+    if content_type == "application/x-autogluon":
+        return _parse_x_autogluon(request_body)
+    raise ValueError(
+        f"{content_type} input content type not supported. "
+        f"Tabular foundation-model endpoints accept only 'application/x-autogluon'."
+    )
+
+
+def _parse_x_autogluon(request_body: bytes) -> ParsedPayload:
+    payload = json.loads(request_body)
+    if payload.get("version") != 1:
+        raise ValueError(f"Unsupported x-autogluon payload version: {payload.get('version')}. Expected 1.")
+
+    train_df = _decode_parquet(payload.get("train_data"))
+    if train_df is None:
+        raise ValueError("Tabular foundation-model payload must include `train_data` (few-shot context).")
+    test_df = _decode_parquet(payload["data"])
+    inference_kwargs = payload.get("inference_kwargs") or {}
+    return train_df, test_df, inference_kwargs
+
+
+def _decode_parquet(b64: Optional[str]) -> Optional[pd.DataFrame]:
+    if b64 is None:
+        return None
+    return pd.read_parquet(BytesIO(base64.b64decode(b64)))
+
+
+def render_response(prediction: pd.DataFrame, accept: str) -> Tuple[Any, str]:
+    """Serialize predictions per the request's ``Accept`` header."""
+    accept = accept.lower()
+    if "application/x-parquet" in accept:
+        prediction = prediction.copy()
+        prediction.columns = prediction.columns.astype(str)
+        return prediction.to_parquet(index=False), "application/x-parquet"
+    if "application/json" in accept:
+        return prediction.to_json(orient="records"), "application/json"
+    if "text/csv" in accept:
+        return prediction.to_csv(index=False), "text/csv"
+    raise ValueError(f"{accept} content type not supported")
diff --git a/src/autogluon/cloud/scripts/sagemaker_scripts/tabular_fm_serve.py b/src/autogluon/cloud/scripts/sagemaker_scripts/tabular_fm_serve.py
new file mode 100644
index 00000000..c1dc590c
--- /dev/null
+++ b/src/autogluon/cloud/scripts/sagemaker_scripts/tabular_fm_serve.py
@@ -0,0 +1,70 @@
+"""Serve script for tabular foundation models (Mitra, TabICL, etc.) on SageMaker endpoints.
+
+Config comes from the AG_SERVE_CONFIG env var (set by the backend at deploy time):
+    {"model_name": "MITRA", "hyperparameters": {...}}
+
+Tabular foundation models perform in-context learning, so each request must include both the
+labeled few-shot context (``train_data``) and the unlabeled rows to predict on (``data``).
+The endpoint instantiates a fresh ``TabularPredictor`` per request, fits it on ``train_data``
+with the configured AG model, and returns combined ``[<label>, <class>_proba, ...]`` predictions
+matching the format produced by the standard tabular serve script.
+"""
+
+import json
+import os
+import shutil
+import tempfile
+
+import pandas as pd
+from serving_utils.tabular import parse_payload, render_response
+
+from autogluon.core.constants import QUANTILE, REGRESSION
+from autogluon.core.utils import get_pred_from_proba_df
+from autogluon.tabular import TabularPredictor
+
+_SERVE_CONFIG = json.loads(os.environ.get("AG_SERVE_CONFIG", "{}"))
+
+
+def model_fn(model_dir):
+    """Return the serve config; the predictor is fit per-request from the request's train_data."""
+    return _SERVE_CONFIG
+
+
+def _resolve_label(train_df: pd.DataFrame, requested_label: str) -> str:
+    if requested_label in train_df.columns:
+        return requested_label
+    raise ValueError(
+        f"Label column {requested_label!r} not found in train_data. Available columns: {list(train_df.columns)}"
+    )
+
+
+def transform_fn(model, request_body, input_content_type, output_content_type="application/json"):
+    train_df, test_df, inference_kwargs = parse_payload(request_body, input_content_type)
+
+    model_name = model["model_name"]
+    hyperparameters = model.get("hyperparameters", {})
+    label = _resolve_label(train_df, inference_kwargs.get("label", "target"))
+
+    tmpdir = tempfile.mkdtemp(prefix="ag_fm_predictor_")
+    try:
+        predictor = TabularPredictor(label=label, path=tmpdir).fit(
+            train_data=train_df,
+            hyperparameters={model_name: hyperparameters},
+            fit_weighted_ensemble=False,
+            calibrate_decision_threshold=False,
+        )
+
+        if predictor.problem_type not in [REGRESSION, QUANTILE]:
+            pred_proba = predictor.predict_proba(test_df, as_pandas=True)
+            pred = get_pred_from_proba_df(pred_proba, problem_type=predictor.problem_type)
+            pred_proba.columns = [str(c) + "_proba" for c in pred_proba.columns]
+            pred.name = predictor.label
+            prediction = pd.concat([pred, pred_proba], axis=1)
+        else:
+            prediction = predictor.predict(test_df, as_pandas=True)
+            if isinstance(prediction, pd.Series):
+                prediction = prediction.to_frame()
+    finally:
+        shutil.rmtree(tmpdir, ignore_errors=True)
+
+    return render_response(prediction, output_content_type)
diff --git a/src/autogluon/cloud/scripts/sagemaker_scripts/train.py b/src/autogluon/cloud/scripts/sagemaker_scripts/train.py
index 100e8e30..bb01d252 100644
--- a/src/autogluon/cloud/scripts/sagemaker_scripts/train.py
+++ b/src/autogluon/cloud/scripts/sagemaker_scripts/train.py
@@ -9,6 +9,7 @@
 from pprint import pprint
 
 import boto3
+import pandas as pd
 import pickle
 
 from autogluon.common.loaders import load_pd
@@ -74,6 +75,7 @@ def prepare_data(data_file, predictor_type, ag_args, static_features_df=None):
     parser.add_argument(
         "--static_features", type=str, required=False, default=get_env_if_present("SM_CHANNEL_STATIC_FEATURES")
     )
+    parser.add_argument("--test_data", type=str, required=False, default=get_env_if_present("SM_CHANNEL_TEST_DATA"))
 
     args, _ = parser.parse_known_args()
 
@@ -176,16 +178,34 @@ def prepare_data(data_file, predictor_type, ag_args, static_features_df=None):
             lb.to_csv(f"{args.output_data_dir}/leaderboard.csv")
 
     if ag_args.get("predict_after_fit", False):
-        if predictor_type != "timeseries":
-            raise NotImplementedError(
-                f"`fit_predict` is only supported for predictor_type='timeseries', got '{predictor_type}'."
-            )
-        print("Running in-job prediction for fit_predict")
-        predictions = predictor.predict(training_data, known_covariates=known_covariates)
+        if predictor_type == "timeseries":
+            print("Running in-job prediction for fit_predict")
+            predictions = predictor.predict(training_data, known_covariates=known_covariates)
+            predictions_df = predictions.to_data_frame().reset_index()
+        elif predictor_type == "tabular":
+            assert args.test_data, "`test_data` channel required for tabular fit_predict"
+            test_data = TabularDataset(get_input_path(args.test_data))
+            print("Running in-job prediction for fit_predict")
+            # Match tabular_serve.py output shape: for classification, write
+            # `[<label>, <class>_proba, ...]` so predict() and predict_proba() share one job.
+            from autogluon.core.constants import QUANTILE, REGRESSION
+            from autogluon.core.utils import get_pred_from_proba_df
+
+            if predictor.problem_type not in [REGRESSION, QUANTILE]:
+                pred_proba = predictor.predict_proba(test_data, as_pandas=True)
+                pred = get_pred_from_proba_df(pred_proba, problem_type=predictor.problem_type)
+                pred_proba.columns = [str(c) + "_proba" for c in pred_proba.columns]
+                pred.name = predictor.label
+                predictions_df = pd.concat([pred, pred_proba], axis=1)
+            else:
+                predictions = predictor.predict(test_data, as_pandas=True)
+                predictions_df = predictions.to_frame() if isinstance(predictions, pd.Series) else predictions
+        else:
+            raise NotImplementedError(f"`fit_predict` is not supported for predictor_type='{predictor_type}'.")
         predictions_path = ag_args["predictions_path"]
         # Save locally then upload via boto3: s3fs/fsspec are not available in the training container.
         local_path = os.path.join(args.output_data_dir, os.path.basename(predictions_path))
-        save_pd.save(path=local_path, df=predictions.to_data_frame().reset_index())
+        save_pd.save(path=local_path, df=predictions_df)
         bucket, key = s3_path_to_bucket_prefix(predictions_path)
         boto3.client("s3").upload_file(local_path, bucket, key)
         print(f"Uploaded predictions to {predictions_path}")
diff --git a/src/autogluon/cloud/scripts/script_manager.py b/src/autogluon/cloud/scripts/script_manager.py
index 9dc93b31..263e8b6d 100644
--- a/src/autogluon/cloud/scripts/script_manager.py
+++ b/src/autogluon/cloud/scripts/script_manager.py
@@ -14,6 +14,7 @@ class ScriptManager:
     SAGEMAKER_MULTIMODAL_SERVE_SCRIPT_PATH = os.path.join(SAGEMAKER_SCRIPTS_PATH, "multimodal_serve.py")
     SAGEMAKER_TIMESERIES_SERVE_SCRIPT_PATH = os.path.join(SAGEMAKER_SCRIPTS_PATH, "timeseries_serve.py")
     SAGEMAKER_TIMESERIES_FM_SERVE_SCRIPT_PATH = os.path.join(SAGEMAKER_SCRIPTS_PATH, "timeseries_fm_serve.py")
+    SAGEMAKER_TABULAR_FM_SERVE_SCRIPT_PATH = os.path.join(SAGEMAKER_SCRIPTS_PATH, "tabular_fm_serve.py")
     SAGEMAKER_SERVING_UTILS_DIR = os.path.join(SAGEMAKER_SCRIPTS_PATH, "serving_utils")
     RAY_TABULAR_TRAIN_SCRIPT_PATH = os.path.join(RAY_SCRIPTS_PATH, "train.py")
     _BACKEND_SERVE_SCRIPT_MAP = {
diff --git a/src/autogluon/cloud/utils/serializers.py b/src/autogluon/cloud/utils/serializers.py
index 9a8a19f2..8ca4eb37 100644
--- a/src/autogluon/cloud/utils/serializers.py
+++ b/src/autogluon/cloud/utils/serializers.py
@@ -31,6 +31,7 @@ class AutoGluonSerializationWrapper:
     inference_kwargs: Dict[str, Any]
     static_features: Optional[pd.DataFrame] = field(default=None)
     known_covariates: Optional[pd.DataFrame] = field(default=None)
+    train_data: Optional[pd.DataFrame] = field(default=None)
 
 
 class AutoGluonSerializer(SimpleBaseSerializer):
@@ -68,6 +69,8 @@ def serialize(self, data: AutoGluonSerializationWrapper):
             package["static_features"] = _dataframe_to_b64(data.static_features)
         if data.known_covariates is not None:
             package["known_covariates"] = _dataframe_to_b64(data.known_covariates)
+        if data.train_data is not None:
+            package["train_data"] = _dataframe_to_b64(data.train_data)
         return json.dumps(package).encode("utf-8")