skypilot-nightly 1.0.0.dev20250819__py3-none-any.whl → 1.0.0.dev20250821__py3-none-any.whl

sky/server/requests/serializers/encoders.py

@@ -10,6 +10,7 @@ from typing import Any, Dict, List, Optional, Tuple
 
 from sky.schemas.api import responses
 from sky.server import constants as server_constants
+from sky.utils import serialize_utils
 
 if typing.TYPE_CHECKING:
     from sky import backends
@@ -22,6 +23,9 @@ handlers: Dict[str, Any] = {}
 
 def pickle_and_encode(obj: Any) -> str:
     try:
+        # Apply backwards compatibility processing at the lowest level
+        # to catch any handles that might have bypassed the encoders
+        obj = serialize_utils.prepare_handle_for_backwards_compatibility(obj)
         return base64.b64encode(pickle.dumps(obj)).decode('utf-8')
     except TypeError as e:
         raise ValueError(f'Failed to pickle object: {obj}') from e
@@ -58,7 +62,9 @@ def encode_status(
     for cluster in clusters:
         response_cluster = cluster.model_dump()
         response_cluster['status'] = cluster['status'].value
-        response_cluster['handle'] = pickle_and_encode(cluster['handle'])
+        handle = serialize_utils.prepare_handle_for_backwards_compatibility(
+            cluster['handle'])
+        response_cluster['handle'] = pickle_and_encode(handle)
         response_cluster['storage_mounts_metadata'] = pickle_and_encode(
             response_cluster['storage_mounts_metadata'])
         response.append(response_cluster)
@@ -70,6 +76,7 @@ def encode_launch(
     job_id_handle: Tuple[Optional[int], Optional['backends.ResourceHandle']]
 ) -> Dict[str, Any]:
     job_id, handle = job_id_handle
+    handle = serialize_utils.prepare_handle_for_backwards_compatibility(handle)
     return {
         'job_id': job_id,
         'handle': pickle_and_encode(handle),
@@ -78,6 +85,9 @@ def encode_launch(
 
 @register_encoder('start')
 def encode_start(resource_handle: 'backends.CloudVmRayResourceHandle') -> str:
+    resource_handle = (
+        serialize_utils.prepare_handle_for_backwards_compatibility(
+            resource_handle))
     return pickle_and_encode(resource_handle)
 
 
@@ -143,7 +153,9 @@ def _encode_serve_status(
         service_status['status'] = service_status['status'].value
         for replica_info in service_status.get('replica_info', []):
             replica_info['status'] = replica_info['status'].value
-            replica_info['handle'] = pickle_and_encode(replica_info['handle'])
+            handle = serialize_utils.prepare_handle_for_backwards_compatibility(
+                replica_info['handle'])
+            replica_info['handle'] = pickle_and_encode(handle)
     return service_statuses
 
 

sky/server/server.py

@@ -83,6 +83,8 @@ else:
 
 P = ParamSpec('P')
 
+_SERVER_USER_HASH_KEY = 'server_user_hash'
+
 
 def _add_timestamp_prefix_for_server_logs() -> None:
     server_logger = sky_logging.init_logger('sky.server')
@@ -1821,6 +1823,35 @@ async def root():
     return fastapi.responses.RedirectResponse(url='/dashboard/')
 
 
+def _init_or_restore_server_user_hash():
+    """Restores the server user hash from the global user state db.
+
+    The API server must have a stable user hash across restarts and potential
+    multiple replicas. Thus we persist the user hash in db and restore it on
+    startup. When upgrading from old version, the user hash will be read from
+    the local file (if any) to keep the user hash consistent.
+    """
+
+    def apply_user_hash(user_hash: str) -> None:
+        # For local API server, the user hash in db and local file should be
+        # same so there is no harm to override here.
+        common_utils.set_user_hash_locally(user_hash)
+        # Refresh the server user hash for current process after restore or
+        # initialize the user hash in db, child processes will get the correct
+        # server id from the local cache file.
+        common_lib.refresh_server_id()
+
+    user_hash = global_user_state.get_system_config(_SERVER_USER_HASH_KEY)
+    if user_hash is not None:
+        apply_user_hash(user_hash)
+        return
+
+    # Initial deployment, generate a user hash and save it to the db.
+    user_hash = common_utils.get_user_hash()
+    global_user_state.set_system_config(_SERVER_USER_HASH_KEY, user_hash)
+    apply_user_hash(user_hash)
+
+
 if __name__ == '__main__':
     import uvicorn
 
@@ -1830,6 +1861,8 @@ if __name__ == '__main__':
     global_user_state.initialize_and_get_db()
     # Initialize request db
     requests_lib.reset_db_and_logs()
+    # Restore the server user hash
+    _init_or_restore_server_user_hash()
 
     parser = argparse.ArgumentParser()
     parser.add_argument('--host', default='127.0.0.1')

sky/setup_files/dependencies.py

@@ -72,12 +72,27 @@ install_requires = [
     'aiohttp',
 ]
 
+# See requirements-dev.txt for the version of grpc and protobuf
+# used to generate the code during development.
+
+# The grpc version at runtime has to be newer than the version
+# used to generate the code.
+GRPC = 'grpcio>=1.63.0'
+# >= 5.26.1 because the runtime version can't be older than the version
+# used to generate the code.
+# < 7.0.0 because code generated for a major version V will be supported by
+# protobuf runtimes of version V and V+1.
+# https://protobuf.dev/support/cross-version-runtime-guarantee
+PROTOBUF = 'protobuf>=5.26.1, < 7.0.0'
+
 server_dependencies = [
     'casbin',
     'sqlalchemy_adapter',
     'passlib',
     'pyjwt',
     'aiohttp',
+    GRPC,
+    PROTOBUF,
 ]
 
 local_ray = [
@@ -88,18 +103,9 @@ local_ray = [
     'ray[default] >= 2.2.0, != 2.6.0',
 ]
 
-# See requirements-dev.txt for the version of grpc and protobuf
-# used to generate the code during development.
 remote = [
-    # The grpc version at runtime has to be newer than the version
-    # used to generate the code.
-    'grpcio>=1.63.0',
-    # >= 5.26.1 because the runtime version can't be older than the version
-    # used to generate the code.
-    # < 7.0.0 because code generated for a major version V will be supported by
-    # protobuf runtimes of version V and V+1.
-    # https://protobuf.dev/support/cross-version-runtime-guarantee
-    'protobuf >= 5.26.1, < 7.0.0',
+    GRPC,
+    PROTOBUF,
 ]
 
 # NOTE: Change the templates/jobs-controller.yaml.j2 file if any of the

sky/skypilot_config.py

@@ -514,10 +514,10 @@ def parse_and_validate_config_file(config_path: str) -> config_utils.Config:
 
 
 def _parse_dotlist(dotlist: List[str]) -> config_utils.Config:
-    """Parse a comma-separated list of key-value pairs into a dictionary.
+    """Parse a single key-value pair into a dictionary.
 
     Args:
-        dotlist: A comma-separated list of key-value pairs.
+        dotlist: A single key-value pair.
 
     Returns:
         A config_utils.Config object with the parsed key-value pairs.
@@ -788,7 +788,7 @@ def _compose_cli_config(cli_config: Optional[List[str]]) -> config_utils.Config:
     """Composes the skypilot CLI config.
     CLI config can either be:
     - A path to a config file
-    - A comma-separated list of key-value pairs
+    - A single key-value pair
     """
 
     if not cli_config:
@@ -804,7 +804,7 @@ def _compose_cli_config(cli_config: Optional[List[str]]) -> config_utils.Config:
             config_source = maybe_config_path
             # cli_config is a path to a config file
             parsed_config = parse_and_validate_config_file(maybe_config_path)
-        else:  # cli_config is a comma-separated list of key-value pairs
+        else:  # cli_config is a single key-value pair
             parsed_config = _parse_dotlist(cli_config)
         _validate_config(parsed_config, config_source)
     except ValueError as e:

sky/users/permission.py

@@ -46,7 +46,8 @@ class PermissionService:
                 engine = global_user_state.initialize_and_get_db()
                 db_utils.add_all_tables_to_db_sqlalchemy(
                     sqlalchemy_adapter.Base.metadata, engine)
-                adapter = sqlalchemy_adapter.Adapter(engine)
+                adapter = sqlalchemy_adapter.Adapter(
+                    engine, db_class=sqlalchemy_adapter.CasbinRule)
                 model_path = os.path.join(os.path.dirname(__file__),
                                           'model.conf')
                 enforcer = casbin.Enforcer(model_path, adapter)

sky/utils/common.py

@@ -11,18 +11,38 @@ from sky.utils import common_utils
 
 SKY_SERVE_CONTROLLER_PREFIX: str = 'sky-serve-controller-'
 JOB_CONTROLLER_PREFIX: str = 'sky-jobs-controller-'
+
 # We use the user hash (machine-specific) for the controller name. It will be
 # the same across the whole lifecycle of the server, including:
-# 1. all requests, because this global variable is set once during server
-#    starts.
-# 2. SkyPilot API server restarts, as long as the `~/.sky` folder is persisted
-#    and the env var set during starting the server is the same.
+# 1. all requests, because all the server processes share the same user hash
+#    cache file.
+# 2. SkyPilot API server restarts, because the API server will restore the
+#    user hash from the global user state db on startup.
+# 3. Potential multiple server replicas, because multiple server replicas of
+#    a same deployment will share the same global user state db.
 # This behavior is the same for the local API server (where SERVER_ID is the
 # same as the normal user hash). This ensures backwards-compatibility with jobs
 # controllers from before #4660.
-SERVER_ID = common_utils.get_user_hash()
-SKY_SERVE_CONTROLLER_NAME: str = f'{SKY_SERVE_CONTROLLER_PREFIX}{SERVER_ID}'
-JOB_CONTROLLER_NAME: str = f'{JOB_CONTROLLER_PREFIX}{SERVER_ID}'
+SERVER_ID: str
+SKY_SERVE_CONTROLLER_NAME: str
+JOB_CONTROLLER_NAME: str
+
+
+def refresh_server_id() -> None:
+    """Refresh the server id.
+
+    This function is used to ensure the server id is read from the authorative
+    source.
+    """
+    global SERVER_ID
+    global SKY_SERVE_CONTROLLER_NAME
+    global JOB_CONTROLLER_NAME
+    SERVER_ID = common_utils.get_user_hash()
+    SKY_SERVE_CONTROLLER_NAME = f'{SKY_SERVE_CONTROLLER_PREFIX}{SERVER_ID}'
+    JOB_CONTROLLER_NAME = f'{JOB_CONTROLLER_PREFIX}{SERVER_ID}'
+
+
+refresh_server_id()
 
 
 @contextlib.contextmanager

sky/utils/common_utils.py

@@ -28,7 +28,6 @@ from sky.adaptors import common as adaptors_common
 from sky.skylet import constants
 from sky.usage import constants as usage_constants
 from sky.utils import annotations
-from sky.utils import common_utils
 from sky.utils import ux_utils
 from sky.utils import validator
 
@@ -41,7 +40,7 @@ else:
     psutil = adaptors_common.LazyImport('psutil')
     yaml = adaptors_common.LazyImport('yaml')
 
-_USER_HASH_FILE = os.path.expanduser('~/.sky/user_hash')
+USER_HASH_FILE = os.path.expanduser('~/.sky/user_hash')
 USER_HASH_LENGTH = 8
 
 # We are using base36 to reduce the length of the hash. 2 chars -> 36^2 = 1296
@@ -131,21 +130,26 @@ def get_user_hash() -> str:
         assert user_hash is not None
         return user_hash
 
-    if os.path.exists(_USER_HASH_FILE):
+    if os.path.exists(USER_HASH_FILE):
         # Read from cached user hash file.
-        with open(_USER_HASH_FILE, 'r', encoding='utf-8') as f:
+        with open(USER_HASH_FILE, 'r', encoding='utf-8') as f:
             # Remove invalid characters.
             user_hash = f.read().strip()
         if is_valid_user_hash(user_hash):
             return user_hash
 
     user_hash = generate_user_hash()
-    os.makedirs(os.path.dirname(_USER_HASH_FILE), exist_ok=True)
-    with open(_USER_HASH_FILE, 'w', encoding='utf-8') as f:
-        f.write(user_hash)
+    set_user_hash_locally(user_hash)
     return user_hash
 
 
+def set_user_hash_locally(user_hash: str) -> None:
+    """Sets the user hash to local file."""
+    os.makedirs(os.path.dirname(USER_HASH_FILE), exist_ok=True)
+    with open(USER_HASH_FILE, 'w', encoding='utf-8') as f:
+        f.write(user_hash)
+
+
 def base36_encode(hex_str: str) -> str:
     """Converts a hex string to a base36 string."""
     int_value = int(hex_str, 16)
@@ -343,7 +347,7 @@ def get_current_user() -> 'models.User':
 
 def get_current_user_name() -> str:
     """Returns the current user name."""
-    name = common_utils.get_current_user().name
+    name = get_current_user().name
     assert name is not None
     return name
 
@@ -886,7 +890,7 @@ def get_cleaned_username(username: str = '') -> str:
     Returns:
       A cleaned username.
     """
-    username = username or common_utils.get_current_user_name()
+    username = username or get_current_user_name()
     username = username.lower()
     username = re.sub(r'[^a-z0-9-_]', '', username)
     username = re.sub(r'^[0-9-]+', '', username)

sky/utils/directory_utils.py

@@ -0,0 +1,12 @@
+"""Directory utilities."""
+
+import os
+
+# This file is in '<project_root>/sky/utils/directory_utils.py'
+# So we need to go up 2 levels to get to the '<project_root>/sky' directory
+SKY_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+def get_sky_dir():
+    """Get the sky root directory."""
+    return SKY_DIR

sky/utils/env_options.py

@@ -24,6 +24,9 @@ class Options(enum.Enum):
     # running in a Buildkite container environment, which requires special
     # handling for networking between containers.
     RUNNING_IN_BUILDKITE = ('BUILDKITE', False)
+    # Internal: This is used for testing to enable grpc for communication
+    # between the API server and the Skylet.
+    ENABLE_GRPC = ('SKYPILOT_ENABLE_GRPC', False)
 
     def __init__(self, env_var: str, default: bool) -> None:
         super().__init__()

sky/utils/kubernetes/gpu_labeler.py

@@ -8,9 +8,9 @@ from typing import Dict, Optional, Tuple
 import colorama
 import yaml
 
-import sky
 from sky.adaptors import kubernetes
 from sky.provision.kubernetes import utils as kubernetes_utils
+from sky.utils import directory_utils
 from sky.utils import rich_utils
 
 
@@ -71,8 +71,8 @@ def label(context: Optional[str] = None, wait_for_completion: bool = True):
             f'Found {len(unlabeled_gpu_nodes)} '
             'unlabeled GPU nodes in the cluster', colorama.Fore.YELLOW))
 
-    sky_dir = os.path.dirname(sky.__file__)
-    manifest_dir = os.path.join(sky_dir, 'utils/kubernetes')
+    manifest_dir = os.path.join(directory_utils.get_sky_dir(),
+                                'utils/kubernetes')
 
     # Apply the RBAC manifest using kubectl since it contains multiple resources
     with rich_utils.client_status('Setting up GPU labeling'):

sky/utils/schemas.py

@@ -481,6 +481,7 @@ def get_volume_schema():
                     },
                 },
             },
+            **_LABELS_SCHEMA,
         }
     }
 

sky/utils/serialize_utils.py

@@ -0,0 +1,16 @@
+"""Utilities for handling resource handles."""
+import copy
+import typing
+
+
+def prepare_handle_for_backwards_compatibility(
+        handle: typing.Any) -> typing.Any:
+    """Prepare a handle for backwards compatibility with older clients."""
+    # skylet_ssh_tunnel was causing backwards compatibility issues with older
+    # clients: AttributeError: Can't get attribute 'SSHTunnelInfo'
+    #
+    # But it is not needed on the client side, so we can just remove it.
+    if handle is not None and hasattr(handle, 'skylet_ssh_tunnel'):
+        handle = copy.deepcopy(handle)
+        handle.skylet_ssh_tunnel = None
+    return handle

sky/volumes/client/sdk.py

@@ -33,13 +33,16 @@ def apply(volume: volume_lib.Volume) -> server_common.RequestId[None]:
     Returns:
         The request ID of the apply request.
     """
-    body = payloads.VolumeApplyBody(name=volume.name,
-                                    volume_type=volume.type,
-                                    cloud=volume.cloud,
-                                    region=volume.region,
-                                    zone=volume.zone,
-                                    size=volume.size,
-                                    config=volume.config)
+    body = payloads.VolumeApplyBody(
+        name=volume.name,
+        volume_type=volume.type,
+        cloud=volume.cloud,
+        region=volume.region,
+        zone=volume.zone,
+        size=volume.size,
+        config=volume.config,
+        labels=volume.labels,
+    )
     response = requests.post(f'{server_common.get_server_url()}/volumes/apply',
                              json=json.loads(body.model_dump_json()),
                              cookies=server_common.get_api_cookie_jar())

sky/volumes/server/core.py

@@ -162,9 +162,16 @@ def volume_delete(names: List[str]) -> None:
                 global_user_state.delete_volume(name)
 
 
-def volume_apply(name: str, volume_type: str, cloud: str, region: Optional[str],
-                 zone: Optional[str], size: Optional[str],
-                 config: Dict[str, Any]) -> None:
+def volume_apply(
+    name: str,
+    volume_type: str,
+    cloud: str,
+    region: Optional[str],
+    zone: Optional[str],
+    size: Optional[str],
+    config: Dict[str, Any],
+    labels: Optional[Dict[str, str]] = None,
+) -> None:
     """Creates or registers a volume.
 
     Args:
@@ -175,6 +182,7 @@ def volume_apply(name: str, volume_type: str, cloud: str, region: Optional[str],
         zone: The zone of the volume.
         size: The size of the volume.
         config: The configuration of the volume.
+        labels: The labels of the volume.
 
     """
     with rich_utils.safe_status(ux_utils.spinner_message('Creating volume')):
@@ -195,6 +203,7 @@ def volume_apply(name: str, volume_type: str, cloud: str, region: Optional[str],
             size=size,
             config=config,
             name_on_cloud=name_on_cloud,
+            labels=labels,
         )
         logger.debug(
             f'Creating volume {name} on cloud {cloud} with config {config}')

sky/volumes/volume.py

@@ -3,6 +3,7 @@ from typing import Any, Dict, Optional
 
 from sky.utils import common_utils
 from sky.utils import infra_utils
+from sky.utils import registry
 from sky.utils import resources_utils
 from sky.utils import schemas
 
@@ -16,6 +17,7 @@ class Volume:
             type: Optional[str] = None,  # pylint: disable=redefined-builtin
             infra: Optional[str] = None,
             size: Optional[str] = None,
+            labels: Optional[Dict[str, str]] = None,
             resource_name: Optional[str] = None,
             config: Optional[Dict[str, Any]] = None):
         """Initialize a Volume instance.
@@ -25,12 +27,14 @@ class Volume:
             type: Volume type (e.g., 'k8s-pvc')
             infra: Infrastructure specification
             size: Volume size
+            labels: Volume labels
             config: Additional configuration
         """
         self.name = name
         self.type = type
         self.infra = infra
         self.size = size
+        self.labels = labels or {}
         self.resource_name = resource_name
         self.config = config or {}
 
@@ -45,6 +49,7 @@ class Volume:
                    type=config_dict.get('type'),
                    infra=config_dict.get('infra'),
                    size=config_dict.get('size'),
+                   labels=config_dict.get('labels'),
                    resource_name=config_dict.get('resource_name'),
                    config=config_dict.get('config', {}))
 
@@ -55,6 +60,7 @@ class Volume:
             'type': self.type,
             'infra': self.infra,
             'size': self.size,
+            'labels': self.labels,
             'resource_name': self.resource_name,
             'config': self.config,
             'cloud': self.cloud,
@@ -94,15 +100,15 @@ class Volume:
         # Adjust the volume config (e.g., parse size)
         self._adjust_config()
 
-        # Validate the volume config
-        self._validate_config()
-
         # Resolve the infrastructure options to cloud, region, zone
         infra_info = infra_utils.InfraInfo.from_str(self.infra)
         self.cloud = infra_info.cloud
         self.region = infra_info.region
         self.zone = infra_info.zone
 
+        # Validate the volume config
+        self._validate_config()
+
     def _adjust_config(self) -> None:
         """Adjust the volume config (e.g., parse size)."""
         if self.size is None:
@@ -123,3 +129,11 @@ class Volume:
             raise ValueError('Size is required for new volumes. '
                              'Please specify the size in the YAML file or '
                              'use the --size flag.')
+        if self.labels:
+            assert self.cloud is not None, 'Cloud must be specified'
+            cloud_obj = registry.CLOUD_REGISTRY.from_str(self.cloud)
+            assert cloud_obj is not None
+            for key, value in self.labels.items():
+                valid, err_msg = cloud_obj.is_label_valid(key, value)
+                if not valid:
+                    raise ValueError(f'{err_msg}')

{skypilot_nightly-1.0.0.dev20250819.dist-info → skypilot_nightly-1.0.0.dev20250821.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skypilot-nightly
-Version: 1.0.0.dev20250819
+Version: 1.0.0.dev20250821
 Summary: SkyPilot: Run AI on Any Infra — Unified, Faster, Cheaper.
 Author: SkyPilot Team
 License: Apache 2.0
@@ -133,6 +133,8 @@ Requires-Dist: sqlalchemy_adapter; extra == "server"
 Requires-Dist: passlib; extra == "server"
 Requires-Dist: pyjwt; extra == "server"
 Requires-Dist: aiohttp; extra == "server"
+Requires-Dist: grpcio>=1.63.0; extra == "server"
+Requires-Dist: protobuf<7.0.0,>=5.26.1; extra == "server"
 Provides-Extra: all
 Requires-Dist: awscli>=1.27.10; extra == "all"
 Requires-Dist: botocore>=1.29.10; extra == "all"
@@ -187,6 +189,8 @@ Requires-Dist: sqlalchemy_adapter; extra == "all"
 Requires-Dist: passlib; extra == "all"
 Requires-Dist: pyjwt; extra == "all"
 Requires-Dist: aiohttp; extra == "all"
+Requires-Dist: grpcio>=1.63.0; extra == "all"
+Requires-Dist: protobuf<7.0.0,>=5.26.1; extra == "all"
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -222,7 +226,7 @@ Dynamic: summary
 </p>
 
 <h3 align="center">
-    Run AI on Any Infra — Unified, Faster, Cheaper
+    Simplify & scale any AI infrastructure
 </h3>
 
 <div align="center">
@@ -242,26 +246,28 @@ Dynamic: summary
 - [Jul 2025] Finetune **Llama4** on any distributed cluster/cloud: [**example**](./llm/llama-4-finetuning/)
 - [Jul 2025] Two-part blog series, `The Evolution of AI Job Orchestration`: (1) [Running AI jobs on GPU Neoclouds](https://blog.skypilot.co/ai-job-orchestration-pt1-gpu-neoclouds/), (2) [The AI-Native Control Plane & Orchestration that Finally Works for ML](https://blog.skypilot.co/ai-job-orchestration-pt2-ai-control-plane/)
 - [Apr 2025] Spin up **Qwen3** on your cluster/cloud: [**example**](./llm/qwen/)
-- [Mar 2025] Run and serve **Google Gemma 3** using SkyPilot [**example**](./llm/gemma3/)
 - [Feb 2025] Prepare and serve **Retrieval Augmented Generation (RAG) with DeepSeek-R1**: [**blog post**](https://blog.skypilot.co/deepseek-rag), [**example**](./llm/rag/)
-- [Feb 2025] Run and serve **DeepSeek-R1 671B** using SkyPilot and SGLang with high throughput: [**example**](./llm/deepseek-r1/)
-- [Feb 2025] Prepare and serve large-scale image search with **vector databases**: [**blog post**](https://blog.skypilot.co/large-scale-vector-database/), [**example**](./examples/vector_database/)
-- [Jan 2025] Launch and serve distilled models from **[DeepSeek-R1](https://github.com/deepseek-ai/DeepSeek-R1)** and **[Janus](https://github.com/deepseek-ai/DeepSeek-Janus)** on Kubernetes or any cloud: [**R1 example**](./llm/deepseek-r1-distilled/) and [**Janus example**](./llm/deepseek-janus/)
-- [Oct 2024] :tada: **SkyPilot crossed 1M+ downloads** :tada:: Thank you to our community! [**Twitter/X**](https://x.com/skypilot_org/status/1844770841718067638)
 
 
 **LLM Finetuning Cookbooks**: Finetuning Llama 2 / Llama 3.1 in your own cloud environment, privately: Llama 2 [**example**](./llm/vicuna-llama-2/) and [**blog**](https://blog.skypilot.co/finetuning-llama2-operational-guide/); Llama 3.1 [**example**](./llm/llama-3_1-finetuning/) and [**blog**](https://blog.skypilot.co/finetune-llama-3_1-on-your-infra/)
 
 ----
 
-SkyPilot is an open-source system for running AI and batch workloads on any infra.
+SkyPilot is a system for running, managing, and scaling AI workloads on any AI infrastructure.
+
+SkyPilot gives **AI teams** a simple interface to run jobs on any infra.
+**Infra teams** get a unified control plane to manage any AI compute — with advanced scheduling, scaling, and orchestration.
 
-SkyPilot **is easy to use for AI users**:
-- Quickly spin up jobs on your own infra
+![](./docs/source/images/skypilot-abstractions-long-2.png)
+
+## Overview
+
+SkyPilot **is easy to use for AI teams**:
+- Quickly spin up compute on your own infra
 - Environment and job as code — simple and portable
-- Easy management: queue, run, and auto-recover many jobs
+- Easy job management: queue, run, and auto-recover many jobs
 
-SkyPilot **makes Kubernetes easy for AI teams**:
+SkyPilot **makes Kubernetes easy for AI & Infra teams**:
 
 - Slurm-like ease of use, cloud-native robustness
 - Local dev experience on K8s: SSH into pods, sync code, or connect IDE
@@ -378,7 +384,9 @@ Source files can be found in [`llm/`](https://github.com/skypilot-org/skypilot/t
 ## More information
 To learn more, see [SkyPilot Overview](https://docs.skypilot.co/en/latest/overview.html), [SkyPilot docs](https://docs.skypilot.co/en/latest/), and [SkyPilot blog](https://blog.skypilot.co/).
 
-Case studies and integrations: [Community Spotlights](https://blog.skypilot.co/community/)
+SkyPilot adopters: [Testimonials and Case Studies](https://blog.skypilot.co/case-studies/)
+
+Partners and integrations: [Community Spotlights](https://blog.skypilot.co/community/)
 
 Follow updates:
 - [Slack](http://slack.skypilot.co)