[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill-aws-labs-mlops":3,"mdc--iw5ci2-key":39,"related-repo-aws-labs-mlops":2454,"related-org-aws-labs-mlops":2551},{"slug":4,"name":4,"fn":5,"description":6,"org":7,"tags":12,"stars":28,"repoUrl":29,"updatedAt":30,"license":31,"forks":32,"topics":33,"repo":34,"sourceUrl":37,"mdContent":38},"mlops","build and manage AWS MLOps pipelines","End-to-end MLOps guidance on AWS — platform selection, training, inference, pipelines, monitoring, and cost optimization. This skill should be used when the user asks to \"build an ML pipeline\", \"deploy a model on SageMaker\", \"set up MLOps\", \"configure SageMaker Pipelines\", \"choose between SageMaker and Bedrock\", \"deploy ML models to production\", \"set up model monitoring\", \"use MLflow on AWS\", \"train a model with Spot instances\", \"configure inference endpoints\", \"set up distributed training\", or mentions SageMaker, MLflow, Kubeflow, ML pipelines, model registry, model monitoring, hyperparameter tuning, inference endpoints, or MLOps on AWS.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},"aws-labs","AWS Labs","https:\u002F\u002Fpexgzepcugksgbtrxkhf.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Forg-logos\u002Faws-labs.png","awslabs",[13,17,20,23,25],{"name":14,"slug":15,"type":16},"Machine Learning","machine-learning","tag",{"name":18,"slug":19,"type":16},"Data Pipeline","data-pipeline",{"name":21,"slug":22,"type":16},"Deployment","deployment",{"name":24,"slug":4,"type":16},"MLOps",{"name":26,"slug":27,"type":16},"AWS","aws",14,"https:\u002F\u002Fgithub.com\u002Fawslabs\u002Fstartups","2026-07-12T08:40:32.336165",null,15,[],{"repoUrl":29,"stars":28,"forks":32,"topics":35,"description":36},[],"Official AWS Startups repository that hosts plugins, skills, tools and resources to support startup builders on AWS","https:\u002F\u002Fgithub.com\u002Fawslabs\u002Fstartups\u002Ftree\u002FHEAD\u002Fsolution-architecture\u002Fplugins\u002Faws-dev-toolkit\u002Fskills\u002Fmlops","---\nname: mlops\ndescription: End-to-end MLOps guidance on AWS — platform selection, training, inference, pipelines, monitoring, and cost optimization. This skill should be used when the user asks to \"build an ML pipeline\", \"deploy a model on SageMaker\", \"set up MLOps\", \"configure SageMaker Pipelines\", \"choose between SageMaker and Bedrock\", \"deploy ML models to production\", \"set up model monitoring\", \"use MLflow on AWS\", \"train a model with Spot instances\", \"configure inference endpoints\", \"set up distributed training\", or mentions SageMaker, MLflow, Kubeflow, ML pipelines, model registry, model monitoring, hyperparameter tuning, inference endpoints, or MLOps on AWS.\n---\n\nSpecialist guidance for MLOps on AWS. Covers platform selection, training job configuration, inference deployment patterns, CI\u002FCD for ML, experiment tracking, model monitoring, and cost optimization.\n\n## Process\n\n1. Identify the ML workload characteristics: model type (classical ML, deep learning, foundation model), training data volume, inference latency requirements, traffic pattern, team expertise\n2. Use the `awsknowledge` MCP tools (`mcp__plugin_aws-dev-toolkit_awsknowledge__aws___search_documentation`, `mcp__plugin_aws-dev-toolkit_awsknowledge__aws___read_documentation`, `mcp__plugin_aws-dev-toolkit_awsknowledge__aws___recommend`) to verify current SageMaker instance types, limits, pricing, and feature availability\n3. Select the appropriate MLOps platform using the decision matrix below\n4. Design the training infrastructure (instance selection, distributed strategy, Spot configuration)\n5. Design the inference topology (real-time, serverless, batch, async)\n6. Configure the ML pipeline (SageMaker Pipelines, Step Functions, or CI\u002FCD integration)\n7. Set up experiment tracking (MLflow on SageMaker or SageMaker Experiments)\n8. Configure model monitoring (data quality, model quality, bias drift, feature attribution drift)\n9. Recommend cost optimization strategies (Spot training, Savings Plans, Inferentia\u002FTrainium, right-sizing)\n\n## Platform Selection Decision Matrix\n\n| Requirement                                                     | Recommendation                               | Why                                                                                                                                                 |\n| --------------------------------------------------------------- | -------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |\n| End-to-end ML platform, team wants managed infrastructure       | SageMaker (full)                             | Integrated training, tuning, deployment, monitoring, and model registry in one service; eliminates infrastructure management                        |\n| CI\u002FCD for ML with automated retraining and approval workflows   | SageMaker Pipelines                          | Native step types for Processing, Training, Tuning, Transform, Model, Condition, and Callback; integrates with Model Registry for approval gates    |\n| Team already uses MLflow, needs portability across clouds       | MLflow on SageMaker (managed)                | Zero-infrastructure MLflow tracking server with automatic SageMaker Model Registry sync; preserves existing MLflow workflows                        |\n| Customizing a foundation model without managing training infra  | Bedrock fine-tuning \u002F continued pre-training | No instance selection, no distributed training config, no checkpointing — AWS manages all training infrastructure; pay per training token           |\n| Kubernetes-native teams with existing EKS clusters              | Kubeflow on EKS                              | Leverages existing K8s expertise and cluster; full control over scheduling, GPU sharing, and custom operators; but significant operational overhead |\n| Simple orchestration for inference-only or lightweight training | Step Functions + Lambda                      | Event-driven, serverless, pay-per-execution; appropriate when training is infrequent and models are small enough for Lambda memory limits           |\n| Large-scale foundation model training (billions of parameters)  | SageMaker HyperPod                           | Persistent managed clusters with automatic fault detection and repair; checkpointless recovery; supports Slurm and EKS orchestration                |\n\n## Training Instance Selection\n\n### Training Instances\n\n| Instance Family           | Accelerator    | Use Case                               | Price-Performance Notes                                                                          |\n| ------------------------- | -------------- | -------------------------------------- | ------------------------------------------------------------------------------------------------ |\n| **ml.trn1 \u002F ml.trn1n**    | AWS Trainium   | Large model training (LLMs, diffusion) | Up to 50% cheaper than comparable GPU instances for supported architectures; requires Neuron SDK |\n| **ml.p5.48xlarge**        | 8x NVIDIA H100 | Largest models, highest performance    | Most powerful GPU option; use when Trainium does not support the model architecture              |\n| **ml.p4d.24xlarge**       | 8x NVIDIA A100 | Large model training                   | Previous-gen flagship; still strong for most distributed training                                |\n| **ml.g5.xlarge-48xlarge** | NVIDIA A10G    | Medium models, fine-tuning             | Good balance of cost and capability for fine-tuning and smaller training jobs                    |\n| **ml.m5.large-24xlarge**  | CPU only       | Classical ML (XGBoost, sklearn)        | No GPU overhead; appropriate for tree-based models and tabular data                              |\n\n### Inference Instances\n\n| Instance Family     | Accelerator     | Use Case                          | Price-Performance Notes                                                                              |\n| ------------------- | --------------- | --------------------------------- | ---------------------------------------------------------------------------------------------------- |\n| **ml.inf2**         | AWS Inferentia2 | LLM and generative AI inference   | Up to 4x higher throughput and 10x lower latency vs Inf1; 50%+ cheaper than GPU for supported models |\n| **ml.g5**           | NVIDIA A10G     | General-purpose GPU inference     | Broad framework support; use when Inferentia does not support the model                              |\n| **ml.g4dn**         | NVIDIA T4       | Cost-effective GPU inference      | Previous-gen but still the cheapest GPU option for small-medium models                               |\n| **ml.c7g \u002F ml.c6g** | Graviton (CPU)  | CPU inference for classical ML    | Best price-performance for models that do not need GPU (XGBoost, sklearn, small NLP)                 |\n| **Serverless**      | Auto-managed    | Sporadic or unpredictable traffic | No idle cost; 1-6 GB memory; cold start latency of seconds; max 60s processing time                  |\n\n### Default to Trainium\u002FInferentia When Possible\n\nAlways evaluate ml.trn1 for training and ml.inf2 for inference before selecting GPU instances. Trainium offers up to 50% cost savings for training and Inferentia2 offers 50%+ cost savings for inference on supported model architectures. The AWS Neuron SDK supports PyTorch and TensorFlow natively. Only fall back to GPU instances when the model architecture is not supported by the Neuron compiler (check the Neuron model support matrix) or when the team needs CUDA-specific libraries.\n\n## Inference Deployment Decision Matrix\n\n| Pattern                  | Latency              | Max Payload   | Timeout               | Cost Model                         | When to Use                                                                |\n| ------------------------ | -------------------- | ------------- | --------------------- | ---------------------------------- | -------------------------------------------------------------------------- |\n| **Real-time endpoint**   | Low (ms)             | 25 MB         | 60s (8 min streaming) | Per-instance-hour (always running) | Consistent traffic with latency SLAs; use auto-scaling to match demand     |\n| **Serverless inference** | Medium (cold start)  | 4 MB          | 60s                   | Per-request + per-ms compute       | Sporadic traffic with idle periods; eliminates idle instance cost entirely |\n| **Batch transform**      | High (minutes-hours) | 100 MB\u002Frecord | Days                  | Per-instance-hour (job duration)   | Offline scoring of large datasets; no persistent endpoint needed           |\n| **Async inference**      | Medium-high          | 1 GB          | 1 hour                | Per-instance-hour (scale to 0)     | Large payloads or long processing; queue-based with SNS notifications      |\n\n### Real-time Endpoint Patterns\n\n- **Single-model endpoint**: One model per endpoint. Simplest. Use for most production deployments.\n- **Multi-model endpoint (MME)**: Thousands of models behind one endpoint, loaded on demand from S3. Use when you have many similar models (per-customer, per-region) and cannot justify an endpoint per model. Trade-off: first-request latency while loading a model.\n- **Multi-container endpoint**: Up to 15 containers per endpoint, invoked individually or as a serial pipeline. Use for A\u002FB testing different model versions or combining pre\u002Fpost-processing with inference.\n- **Shadow testing**: Route production traffic to both current and candidate models simultaneously. Compare metrics before promoting. Always use shadow testing before replacing a production model because it reveals performance differences under real traffic that offline evaluation cannot capture.\n\n### Auto-Scaling\n\nDefault to target-tracking scaling on `SageMakerVariantInvocationsPerInstance` because it automatically adjusts instance count based on actual request load without requiring manual threshold tuning.\n\n```\nTarget value: start at 70% of the max RPS the instance can handle (benchmark first)\nScale-in cooldown: 300 seconds (prevent flapping)\nScale-out cooldown: 60 seconds (respond quickly to load spikes)\n```\n\nUse Inference Recommender before production deployment to benchmark instance types and find the optimal instance\u002Fmodel combination. It runs load tests and reports latency, throughput, and cost per inference, replacing guesswork with data.\n\n## SageMaker Pipelines\n\n### Pipeline Step Types\n\n| Step             | Purpose                                    | Notes                                                       |\n| ---------------- | ------------------------------------------ | ----------------------------------------------------------- |\n| **Processing**   | Data prep, feature engineering, evaluation | Runs a processing container (sklearn, Spark, custom)        |\n| **Training**     | Model training                             | Supports all SageMaker training job features including Spot |\n| **Tuning**       | Hyperparameter optimization                | Bayesian, Random, Grid, or Hyperband strategies             |\n| **Transform**    | Batch inference                            | Run batch predictions as a pipeline step                    |\n| **Model**        | Create\u002Fregister model                      | Register in Model Registry with metadata                    |\n| **Condition**    | Branching logic                            | Route pipeline based on metrics (e.g., accuracy threshold)  |\n| **Callback**     | External integration                       | Wait for external approval or process completion            |\n| **Lambda**       | Run a Lambda function                      | Lightweight compute for custom logic                        |\n| **QualityCheck** | Data\u002Fmodel quality check                   | Integrates with Model Monitor baselines                     |\n| **ClarifyCheck** | Bias and explainability                    | Integrates with SageMaker Clarify                           |\n| **Fail**         | Terminate with error                       | Explicit failure with message for debugging                 |\n\n### Model Registry\n\nThe Model Registry is the central artifact store for production ML. Always register models through the registry because it provides:\n\n- **Version tracking**: Every model gets an immutable version number with metadata (metrics, parameters, data lineage)\n- **Approval workflows**: Models must be explicitly approved (manual or automated) before deployment, preventing untested models from reaching production\n- **Lineage**: Links model versions to the training job, dataset, pipeline execution, and code commit that produced them\n- **Cross-account deployment**: Approved models can be deployed to staging\u002Fproduction accounts via resource policies\n\n### Pipeline Best Practices\n\n- **Parameterize everything**: Instance types, data paths, hyperparameters, and thresholds should be pipeline parameters, not hardcoded values. This enables reuse across environments (dev\u002Fstaging\u002Fprod) without code changes.\n- **Use Condition steps for quality gates**: After training, compare the candidate model metric against a threshold. Only register and deploy if the metric passes. This prevents model regressions from reaching production.\n- **Cache pipeline steps**: Enable step caching to skip unchanged steps on re-execution, reducing pipeline run time and cost.\n- **Trigger pipelines from CI\u002FCD**: Use CodePipeline or GitHub Actions to trigger SageMaker Pipelines on code merge, creating a full ML CI\u002FCD loop.\n\n## MLflow on AWS\n\n### Managed MLflow on SageMaker (Recommended Default)\n\nUse managed MLflow on SageMaker as the default experiment tracking solution because it requires zero infrastructure management, scales automatically, and synchronizes with SageMaker Model Registry automatically.\n\n- **MLflow Apps**: Latest offering with faster startup, cross-account sharing, and automatic model registration\n- **MLflow Tracking Servers**: Traditional MLflow with configurable compute and storage; each project can have its own server\n- Artifacts stored in S3 (durable, shareable, versioned)\n- Native integration with SageMaker training jobs — metrics logged automatically\n- Models registered in MLflow automatically appear in SageMaker Model Registry\n- Deploy MLflow models directly to SageMaker endpoints without custom containers\n\n### Self-Hosted MLflow on EKS\n\nOnly choose self-hosted MLflow when you need custom plugins, specific MLflow versions not yet supported by the managed service, or multi-cloud portability with a single MLflow backend.\n\n- Deploy MLflow server as a Kubernetes Deployment on EKS\n- Use Amazon RDS (PostgreSQL) as the metadata\u002Fbackend store for durability and query performance\n- Use S3 as the artifact store with a dedicated bucket and lifecycle policies\n- Front with an ALB + Cognito or IAM for authentication\n- Operational overhead: you own patching, scaling, backups, and availability\n\n### When to Choose MLflow over Native SageMaker Experiments\n\n- Team has existing MLflow workflows and muscle memory\n- Multi-cloud or hybrid-cloud requirement where portability matters\n- Need for MLflow-specific features (Prompt Registry, advanced tracing for agentic workflows)\n- Want a single UI for experiment comparison across SageMaker and non-SageMaker training runs\n\n## Model Monitoring\n\n### Four Monitoring Dimensions\n\n| Monitor Type                  | What It Detects                                                        | Baseline Source                          | When to Use                                                                  |\n| ----------------------------- | ---------------------------------------------------------------------- | ---------------------------------------- | ---------------------------------------------------------------------------- |\n| **Data Quality**              | Schema violations, missing values, statistical drift in input features | Training dataset statistics              | Always — this is the earliest signal that something changed                  |\n| **Model Quality**             | Accuracy\u002Fprecision\u002Frecall\u002FRMSE degradation                             | Baseline predictions + ground truth      | When ground truth labels are available (even delayed)                        |\n| **Bias Drift**                | Changes in model fairness across demographic groups                    | Pre-deployment bias metrics from Clarify | When the model makes decisions affecting people (lending, hiring, content)   |\n| **Feature Attribution Drift** | Shifts in which features drive predictions                             | SHAP values from Clarify baseline        | When you need to explain why predictions changed, not just that they changed |\n\n### Monitoring Setup\n\n1. **Enable Data Capture** on the endpoint to log inputs and outputs to S3 (asynchronous, no performance impact on inference)\n2. **Create baselines** from the training dataset using `DefaultModelMonitor` for data quality or `ModelQualityMonitor` for model quality\n3. **Schedule monitoring jobs** — hourly for high-traffic endpoints, daily for moderate traffic\n4. **Configure CloudWatch alarms** on monitoring violations to trigger SNS notifications\n5. **Automate retraining**: Use EventBridge to trigger a SageMaker Pipeline re-execution when monitoring detects sustained drift\n\n### When to Retrain vs When to Investigate\n\n- **Retrain** when data quality monitoring shows gradual statistical drift (feature distributions shifting over time) and the model's accuracy metrics are declining — this is expected model staleness\n- **Investigate first** when monitoring shows sudden, sharp changes — this typically indicates an upstream data pipeline issue, a schema change, or a bug, not genuine drift; retraining on bad data makes things worse\n\n## Distributed Training\n\n### Data Parallel\n\nUse data parallel training when the model fits in a single GPU's memory but training is slow due to dataset size. Each GPU processes a different data batch, gradients are synchronized across GPUs. SageMaker's distributed data parallelism (SMDDP) library optimizes AllReduce\u002FAllGather operations for better inter-node communication.\n\n### Model Parallel\n\nUse model parallel training when the model does not fit in a single GPU's memory (large language models, large vision transformers). SageMaker's model parallelism (SMP) library supports tensor parallelism, pipeline parallelism, and expert parallelism. Use EFA-enabled instances (ml.p4d, ml.p5, ml.trn1) for model parallel training because inter-node communication is the bottleneck and EFA provides 400-3200 Gbps networking.\n\n### Hyperparameter Tuning Strategies\n\n| Strategy               | When to Use                              | Notes                                                                        |\n| ---------------------- | ---------------------------------------- | ---------------------------------------------------------------------------- |\n| **Bayesian** (default) | Most cases                               | Uses prior results to choose next trials; converges faster with fewer trials |\n| **Random**             | Large search spaces with many parameters | Good baseline; easy to parallelize                                           |\n| **Grid**               | Small discrete search spaces             | Exhaustive; only practical with few parameters and few values each           |\n| **Hyperband**          | Need results fast on a budget            | Early-stops poor configurations; allocates more resources to promising ones  |\n\nAlways use Bayesian optimization as the default because it typically finds better hyperparameters in fewer trials than random search, directly reducing training cost.\n\n## Cost Optimization\n\n### Managed Spot Training\n\nAlways use Managed Spot Training for training jobs because training is inherently fault-tolerant (checkpointing lets you resume from the last saved state) and Spot provides 60-90% savings over On-Demand. The only exception is ultra-time-sensitive training where any interruption is unacceptable (rare in practice).\n\n- Enable with `use_spot_instances=True` in the Estimator\n- Set `max_wait` to 2x the expected training time to allow for interruptions\n- Enable checkpointing to S3 so training resumes from the last checkpoint, not from scratch\n- SageMaker automatically handles Spot interruption, checkpoint save, and job restart\n\n### SageMaker Savings Plans\n\nCommit to consistent SageMaker usage (measured in $\u002Fhour) for 1 or 3 years. Savings Plans cover Studio Notebooks, Processing, Training, Real-Time Inference, and Batch Transform. Up to 64% savings over On-Demand. Use for production inference endpoints that run continuously.\n\n### Serverless Inference for Sporadic Traffic\n\nUse Serverless Inference instead of real-time endpoints when traffic is sporadic or unpredictable. Real-time endpoints charge per instance-hour even when idle; Serverless charges per request and per millisecond of compute. A real-time ml.m5.large endpoint costs ~$100\u002Fmonth idle. Serverless at 100 requests\u002Fday costs under $5\u002Fmonth.\n\n### Instance Right-Sizing with Inference Recommender\n\nRun SageMaker Inference Recommender before deploying to production. It benchmarks your model across instance types and reports latency percentiles, throughput, and cost per inference. Teams that skip this step typically overprovision by 2-3x because they guess conservatively.\n\n### Trainium and Inferentia\n\nEvaluate Trainium (ml.trn1) for training and Inferentia2 (ml.inf2) for inference on every ML project. For supported model architectures (most PyTorch and TensorFlow models), these custom silicon instances deliver 50%+ cost savings compared to GPU instances. The Neuron SDK compiles models for these chips with minimal code changes. Only skip when the model uses CUDA-specific operations that Neuron does not support.\n\n## Anti-Patterns\n\n- **Training on notebooks instead of training jobs.** Notebook training is not reproducible, cannot use Spot instances (60-90% savings lost), cannot distribute across multiple instances, and produces no training job metadata for lineage tracking. Always convert notebook experiments to SageMaker Training Jobs for anything beyond initial prototyping.\n\n- **Skipping Model Registry.** Without a registry, there is no version history, no approval workflow, no lineage from model to training data, and no clean rollback path. A bad model deployed without registry tracking requires manual forensics to identify what changed.\n\n- **Real-time endpoints for batch workloads.** A real-time endpoint running 24\u002F7 to process a nightly batch job wastes money on 23 hours of idle compute. Batch Transform provisions instances only for the job duration and terminates them automatically.\n\n- **Single large instance instead of distributed training.** A single ml.p5.48xlarge costs more per hour than multiple smaller instances delivering equivalent total compute. Distributed training also provides fault tolerance — if one node fails, only that node's work is lost, not the entire job.\n\n- **No model monitoring after deployment.** Without monitoring, model drift goes undetected. Predictions degrade silently, and the team only discovers the problem when business metrics drop — weeks or months later. Data quality monitoring catches drift within hours.\n\n- **On-Demand training instances by default.** SageMaker Managed Spot Training saves 60-90% and handles interruptions automatically with checkpointing. Training jobs are inherently resumable, making them ideal Spot workloads. On-Demand should be the exception, not the default.\n\n- **Deploying directly to production without shadow testing.** Shadow testing routes live traffic to both the current and candidate models, comparing predictions and latency in real-time. Without it, the only signal that a new model is worse comes from production users experiencing degraded results.\n\n- **Not using experiment tracking (MLflow or SageMaker Experiments).** Without experiment tracking, it is impossible to reproduce a previous result, compare hyperparameter choices across runs, or explain why one model version outperformed another. This wastes compute re-running experiments that were already tried.\n\n- **Storing artifacts locally instead of S3.** Local artifacts are not durable (instance termination deletes them), not shareable across team members, and break CI\u002FCD pipelines that expect S3 paths. S3 provides versioning, cross-account access, and lifecycle management.\n\n- **Ignoring Trainium\u002FInferentia.** ml.trn1 and ml.inf2 instances deliver 50%+ cost savings for supported model architectures. Teams that default to GPU without evaluating Neuron compatibility leave significant savings on the table. The Neuron SDK supports PyTorch and TensorFlow natively with minimal code changes.\n\n- **Hardcoding instance types and hyperparameters in pipeline definitions.** Non-parameterized pipelines cannot be reused across environments (dev\u002Fstaging\u002Fprod) and require code changes for every configuration adjustment. Use SageMaker Pipeline parameters for all configurable values.\n\n- **Manual model deployment without CI\u002FCD.** Manual deployments are error-prone, unauditable, and slow. Use SageMaker Pipelines or CodePipeline to automate the path from model registration to staging to production, with approval gates at each stage.\n\n## Additional Resources\n\n### Reference Files\n\nFor detailed configurations, CLI commands, and code examples, consult:\n\n- **`references\u002Ftraining-patterns.md`** — Training job configurations (single-instance, distributed, Spot), hyperparameter tuning setup, checkpointing, SageMaker Processing examples, and distributed training strategies\n- **`references\u002Finference-deployment.md`** — Real-time endpoint configurations, serverless inference, batch transform, async inference, auto-scaling policies, multi-model endpoints, shadow testing, and Inference Recommender usage\n- **`references\u002Fpipeline-recipes.md`** — SageMaker Pipeline definitions (Python SDK), Model Registry workflows, CI\u002FCD integration with CodePipeline, MLflow experiment tracking setup, and monitoring configuration\n\n### Related Skills\n\n- **`bedrock`** — Foundation model customization, fine-tuning, and Bedrock-native inference\n- **`eks`** — Kubernetes cluster design for Kubeflow or self-hosted MLflow deployments\n- **`lambda`** — Serverless compute for lightweight ML inference or pipeline triggers\n- **`step-functions`** — Workflow orchestration for simple ML pipelines without SageMaker Pipelines\n- **`s3`** — Data lake design, artifact storage, lifecycle policies for training data and model artifacts\n- **`iam`** — Least-privilege roles for SageMaker execution, cross-account model deployment\n- **`observability`** — CloudWatch dashboards, alarms, and logging for ML infrastructure\n- **`cost-check`** — Detailed cost analysis, Savings Plans recommendations, and Spot vs On-Demand comparison\n- **`ec2`** — Instance type selection for self-managed training clusters or custom inference servers\n\n## Output Format\n\nWhen recommending an MLOps architecture, include:\n\n| Component           | Choice                                       | Rationale                                            |\n| ------------------- | -------------------------------------------- | ---------------------------------------------------- |\n| Platform            | SageMaker Pipelines + MLflow                 | CI\u002FCD for ML with experiment tracking                |\n| Training Instance   | ml.trn1.32xlarge (Spot)                      | Trainium for 50% savings; Spot for additional 60-90% |\n| Inference Instance  | ml.inf2.xlarge                               | Inferentia2 for cost-effective LLM serving           |\n| Inference Pattern   | Real-time endpoint with auto-scaling         | Consistent traffic with latency SLA                  |\n| Experiment Tracking | Managed MLflow on SageMaker                  | Zero-infra setup, auto-sync with Model Registry      |\n| Monitoring          | Model Monitor (data quality + model quality) | Detect drift before business impact                  |\n| CI\u002FCD               | CodePipeline triggering SageMaker Pipeline   | Automated training on code merge                     |\n| Cost Optimization   | Spot training + Savings Plan on inference    | Minimize both training and serving costs             |\n\nInclude estimated monthly cost range using the `cost-check` skill.\n",{"data":40,"body":41},{"name":4,"description":6},{"type":42,"children":43},"root",[44,52,59,141,147,306,312,319,482,488,645,651,656,662,848,854,898,904,917,929,934,939,945,1203,1209,1214,1257,1263,1306,1312,1318,1323,1366,1372,1377,1405,1411,1434,1440,1446,1581,1587,1656,1662,1685,1691,1697,1702,1708,1713,1719,1830,1835,1841,1847,1852,1891,1897,1902,1908,1913,1919,1924,1930,1935,1941,2064,2070,2076,2081,2126,2132,2261,2267,2272,2442],{"type":45,"tag":46,"props":47,"children":48},"element","p",{},[49],{"type":50,"value":51},"text","Specialist guidance for MLOps on AWS. Covers platform selection, training job configuration, inference deployment patterns, CI\u002FCD for ML, experiment tracking, model monitoring, and cost optimization.",{"type":45,"tag":53,"props":54,"children":56},"h2",{"id":55},"process",[57],{"type":50,"value":58},"Process",{"type":45,"tag":60,"props":61,"children":62},"ol",{},[63,69,106,111,116,121,126,131,136],{"type":45,"tag":64,"props":65,"children":66},"li",{},[67],{"type":50,"value":68},"Identify the ML workload characteristics: model type (classical ML, deep learning, foundation model), training data volume, inference latency requirements, traffic pattern, team expertise",{"type":45,"tag":64,"props":70,"children":71},{},[72,74,81,83,89,91,97,98,104],{"type":50,"value":73},"Use the ",{"type":45,"tag":75,"props":76,"children":78},"code",{"className":77},[],[79],{"type":50,"value":80},"awsknowledge",{"type":50,"value":82}," MCP tools (",{"type":45,"tag":75,"props":84,"children":86},{"className":85},[],[87],{"type":50,"value":88},"mcp__plugin_aws-dev-toolkit_awsknowledge__aws___search_documentation",{"type":50,"value":90},", ",{"type":45,"tag":75,"props":92,"children":94},{"className":93},[],[95],{"type":50,"value":96},"mcp__plugin_aws-dev-toolkit_awsknowledge__aws___read_documentation",{"type":50,"value":90},{"type":45,"tag":75,"props":99,"children":101},{"className":100},[],[102],{"type":50,"value":103},"mcp__plugin_aws-dev-toolkit_awsknowledge__aws___recommend",{"type":50,"value":105},") to verify current SageMaker instance types, limits, pricing, and feature availability",{"type":45,"tag":64,"props":107,"children":108},{},[109],{"type":50,"value":110},"Select the appropriate MLOps platform using the decision matrix below",{"type":45,"tag":64,"props":112,"children":113},{},[114],{"type":50,"value":115},"Design the training infrastructure (instance selection, distributed strategy, Spot configuration)",{"type":45,"tag":64,"props":117,"children":118},{},[119],{"type":50,"value":120},"Design the inference topology (real-time, serverless, batch, async)",{"type":45,"tag":64,"props":122,"children":123},{},[124],{"type":50,"value":125},"Configure the ML pipeline (SageMaker Pipelines, Step Functions, or CI\u002FCD integration)",{"type":45,"tag":64,"props":127,"children":128},{},[129],{"type":50,"value":130},"Set up experiment tracking (MLflow on SageMaker or SageMaker Experiments)",{"type":45,"tag":64,"props":132,"children":133},{},[134],{"type":50,"value":135},"Configure model monitoring (data quality, model quality, bias drift, feature attribution drift)",{"type":45,"tag":64,"props":137,"children":138},{},[139],{"type":50,"value":140},"Recommend cost optimization strategies (Spot training, Savings Plans, Inferentia\u002FTrainium, right-sizing)",{"type":45,"tag":53,"props":142,"children":144},{"id":143},"platform-selection-decision-matrix",[145],{"type":50,"value":146},"Platform Selection Decision Matrix",{"type":45,"tag":148,"props":149,"children":150},"table",{},[151,175],{"type":45,"tag":152,"props":153,"children":154},"thead",{},[155],{"type":45,"tag":156,"props":157,"children":158},"tr",{},[159,165,170],{"type":45,"tag":160,"props":161,"children":162},"th",{},[163],{"type":50,"value":164},"Requirement",{"type":45,"tag":160,"props":166,"children":167},{},[168],{"type":50,"value":169},"Recommendation",{"type":45,"tag":160,"props":171,"children":172},{},[173],{"type":50,"value":174},"Why",{"type":45,"tag":176,"props":177,"children":178},"tbody",{},[179,198,216,234,252,270,288],{"type":45,"tag":156,"props":180,"children":181},{},[182,188,193],{"type":45,"tag":183,"props":184,"children":185},"td",{},[186],{"type":50,"value":187},"End-to-end ML platform, team wants managed infrastructure",{"type":45,"tag":183,"props":189,"children":190},{},[191],{"type":50,"value":192},"SageMaker (full)",{"type":45,"tag":183,"props":194,"children":195},{},[196],{"type":50,"value":197},"Integrated training, tuning, deployment, monitoring, and model registry in one service; eliminates infrastructure management",{"type":45,"tag":156,"props":199,"children":200},{},[201,206,211],{"type":45,"tag":183,"props":202,"children":203},{},[204],{"type":50,"value":205},"CI\u002FCD for ML with automated retraining and approval workflows",{"type":45,"tag":183,"props":207,"children":208},{},[209],{"type":50,"value":210},"SageMaker Pipelines",{"type":45,"tag":183,"props":212,"children":213},{},[214],{"type":50,"value":215},"Native step types for Processing, Training, Tuning, Transform, Model, Condition, and Callback; integrates with Model Registry for approval gates",{"type":45,"tag":156,"props":217,"children":218},{},[219,224,229],{"type":45,"tag":183,"props":220,"children":221},{},[222],{"type":50,"value":223},"Team already uses MLflow, needs portability across clouds",{"type":45,"tag":183,"props":225,"children":226},{},[227],{"type":50,"value":228},"MLflow on SageMaker (managed)",{"type":45,"tag":183,"props":230,"children":231},{},[232],{"type":50,"value":233},"Zero-infrastructure MLflow tracking server with automatic SageMaker Model Registry sync; preserves existing MLflow workflows",{"type":45,"tag":156,"props":235,"children":236},{},[237,242,247],{"type":45,"tag":183,"props":238,"children":239},{},[240],{"type":50,"value":241},"Customizing a foundation model without managing training infra",{"type":45,"tag":183,"props":243,"children":244},{},[245],{"type":50,"value":246},"Bedrock fine-tuning \u002F continued pre-training",{"type":45,"tag":183,"props":248,"children":249},{},[250],{"type":50,"value":251},"No instance selection, no distributed training config, no checkpointing — AWS manages all training infrastructure; pay per training token",{"type":45,"tag":156,"props":253,"children":254},{},[255,260,265],{"type":45,"tag":183,"props":256,"children":257},{},[258],{"type":50,"value":259},"Kubernetes-native teams with existing EKS clusters",{"type":45,"tag":183,"props":261,"children":262},{},[263],{"type":50,"value":264},"Kubeflow on EKS",{"type":45,"tag":183,"props":266,"children":267},{},[268],{"type":50,"value":269},"Leverages existing K8s expertise and cluster; full control over scheduling, GPU sharing, and custom operators; but significant operational overhead",{"type":45,"tag":156,"props":271,"children":272},{},[273,278,283],{"type":45,"tag":183,"props":274,"children":275},{},[276],{"type":50,"value":277},"Simple orchestration for inference-only or lightweight training",{"type":45,"tag":183,"props":279,"children":280},{},[281],{"type":50,"value":282},"Step Functions + Lambda",{"type":45,"tag":183,"props":284,"children":285},{},[286],{"type":50,"value":287},"Event-driven, serverless, pay-per-execution; appropriate when training is infrequent and models are small enough for Lambda memory limits",{"type":45,"tag":156,"props":289,"children":290},{},[291,296,301],{"type":45,"tag":183,"props":292,"children":293},{},[294],{"type":50,"value":295},"Large-scale foundation model training (billions of parameters)",{"type":45,"tag":183,"props":297,"children":298},{},[299],{"type":50,"value":300},"SageMaker HyperPod",{"type":45,"tag":183,"props":302,"children":303},{},[304],{"type":50,"value":305},"Persistent managed clusters with automatic fault detection and repair; checkpointless recovery; supports Slurm and EKS orchestration",{"type":45,"tag":53,"props":307,"children":309},{"id":308},"training-instance-selection",[310],{"type":50,"value":311},"Training Instance Selection",{"type":45,"tag":313,"props":314,"children":316},"h3",{"id":315},"training-instances",[317],{"type":50,"value":318},"Training Instances",{"type":45,"tag":148,"props":320,"children":321},{},[322,348],{"type":45,"tag":152,"props":323,"children":324},{},[325],{"type":45,"tag":156,"props":326,"children":327},{},[328,333,338,343],{"type":45,"tag":160,"props":329,"children":330},{},[331],{"type":50,"value":332},"Instance Family",{"type":45,"tag":160,"props":334,"children":335},{},[336],{"type":50,"value":337},"Accelerator",{"type":45,"tag":160,"props":339,"children":340},{},[341],{"type":50,"value":342},"Use Case",{"type":45,"tag":160,"props":344,"children":345},{},[346],{"type":50,"value":347},"Price-Performance Notes",{"type":45,"tag":176,"props":349,"children":350},{},[351,378,404,430,456],{"type":45,"tag":156,"props":352,"children":353},{},[354,363,368,373],{"type":45,"tag":183,"props":355,"children":356},{},[357],{"type":45,"tag":358,"props":359,"children":360},"strong",{},[361],{"type":50,"value":362},"ml.trn1 \u002F ml.trn1n",{"type":45,"tag":183,"props":364,"children":365},{},[366],{"type":50,"value":367},"AWS Trainium",{"type":45,"tag":183,"props":369,"children":370},{},[371],{"type":50,"value":372},"Large model training (LLMs, diffusion)",{"type":45,"tag":183,"props":374,"children":375},{},[376],{"type":50,"value":377},"Up to 50% cheaper than comparable GPU instances for supported architectures; requires Neuron SDK",{"type":45,"tag":156,"props":379,"children":380},{},[381,389,394,399],{"type":45,"tag":183,"props":382,"children":383},{},[384],{"type":45,"tag":358,"props":385,"children":386},{},[387],{"type":50,"value":388},"ml.p5.48xlarge",{"type":45,"tag":183,"props":390,"children":391},{},[392],{"type":50,"value":393},"8x NVIDIA H100",{"type":45,"tag":183,"props":395,"children":396},{},[397],{"type":50,"value":398},"Largest models, highest performance",{"type":45,"tag":183,"props":400,"children":401},{},[402],{"type":50,"value":403},"Most powerful GPU option; use when Trainium does not support the model architecture",{"type":45,"tag":156,"props":405,"children":406},{},[407,415,420,425],{"type":45,"tag":183,"props":408,"children":409},{},[410],{"type":45,"tag":358,"props":411,"children":412},{},[413],{"type":50,"value":414},"ml.p4d.24xlarge",{"type":45,"tag":183,"props":416,"children":417},{},[418],{"type":50,"value":419},"8x NVIDIA A100",{"type":45,"tag":183,"props":421,"children":422},{},[423],{"type":50,"value":424},"Large model training",{"type":45,"tag":183,"props":426,"children":427},{},[428],{"type":50,"value":429},"Previous-gen flagship; still strong for most distributed training",{"type":45,"tag":156,"props":431,"children":432},{},[433,441,446,451],{"type":45,"tag":183,"props":434,"children":435},{},[436],{"type":45,"tag":358,"props":437,"children":438},{},[439],{"type":50,"value":440},"ml.g5.xlarge-48xlarge",{"type":45,"tag":183,"props":442,"children":443},{},[444],{"type":50,"value":445},"NVIDIA A10G",{"type":45,"tag":183,"props":447,"children":448},{},[449],{"type":50,"value":450},"Medium models, fine-tuning",{"type":45,"tag":183,"props":452,"children":453},{},[454],{"type":50,"value":455},"Good balance of cost and capability for fine-tuning and smaller training jobs",{"type":45,"tag":156,"props":457,"children":458},{},[459,467,472,477],{"type":45,"tag":183,"props":460,"children":461},{},[462],{"type":45,"tag":358,"props":463,"children":464},{},[465],{"type":50,"value":466},"ml.m5.large-24xlarge",{"type":45,"tag":183,"props":468,"children":469},{},[470],{"type":50,"value":471},"CPU only",{"type":45,"tag":183,"props":473,"children":474},{},[475],{"type":50,"value":476},"Classical ML (XGBoost, sklearn)",{"type":45,"tag":183,"props":478,"children":479},{},[480],{"type":50,"value":481},"No GPU overhead; appropriate for tree-based models and tabular data",{"type":45,"tag":313,"props":483,"children":485},{"id":484},"inference-instances",[486],{"type":50,"value":487},"Inference Instances",{"type":45,"tag":148,"props":489,"children":490},{},[491,513],{"type":45,"tag":152,"props":492,"children":493},{},[494],{"type":45,"tag":156,"props":495,"children":496},{},[497,501,505,509],{"type":45,"tag":160,"props":498,"children":499},{},[500],{"type":50,"value":332},{"type":45,"tag":160,"props":502,"children":503},{},[504],{"type":50,"value":337},{"type":45,"tag":160,"props":506,"children":507},{},[508],{"type":50,"value":342},{"type":45,"tag":160,"props":510,"children":511},{},[512],{"type":50,"value":347},{"type":45,"tag":176,"props":514,"children":515},{},[516,542,567,593,619],{"type":45,"tag":156,"props":517,"children":518},{},[519,527,532,537],{"type":45,"tag":183,"props":520,"children":521},{},[522],{"type":45,"tag":358,"props":523,"children":524},{},[525],{"type":50,"value":526},"ml.inf2",{"type":45,"tag":183,"props":528,"children":529},{},[530],{"type":50,"value":531},"AWS Inferentia2",{"type":45,"tag":183,"props":533,"children":534},{},[535],{"type":50,"value":536},"LLM and generative AI inference",{"type":45,"tag":183,"props":538,"children":539},{},[540],{"type":50,"value":541},"Up to 4x higher throughput and 10x lower latency vs Inf1; 50%+ cheaper than GPU for supported models",{"type":45,"tag":156,"props":543,"children":544},{},[545,553,557,562],{"type":45,"tag":183,"props":546,"children":547},{},[548],{"type":45,"tag":358,"props":549,"children":550},{},[551],{"type":50,"value":552},"ml.g5",{"type":45,"tag":183,"props":554,"children":555},{},[556],{"type":50,"value":445},{"type":45,"tag":183,"props":558,"children":559},{},[560],{"type":50,"value":561},"General-purpose GPU inference",{"type":45,"tag":183,"props":563,"children":564},{},[565],{"type":50,"value":566},"Broad framework support; use when Inferentia does not support the model",{"type":45,"tag":156,"props":568,"children":569},{},[570,578,583,588],{"type":45,"tag":183,"props":571,"children":572},{},[573],{"type":45,"tag":358,"props":574,"children":575},{},[576],{"type":50,"value":577},"ml.g4dn",{"type":45,"tag":183,"props":579,"children":580},{},[581],{"type":50,"value":582},"NVIDIA T4",{"type":45,"tag":183,"props":584,"children":585},{},[586],{"type":50,"value":587},"Cost-effective GPU inference",{"type":45,"tag":183,"props":589,"children":590},{},[591],{"type":50,"value":592},"Previous-gen but still the cheapest GPU option for small-medium models",{"type":45,"tag":156,"props":594,"children":595},{},[596,604,609,614],{"type":45,"tag":183,"props":597,"children":598},{},[599],{"type":45,"tag":358,"props":600,"children":601},{},[602],{"type":50,"value":603},"ml.c7g \u002F ml.c6g",{"type":45,"tag":183,"props":605,"children":606},{},[607],{"type":50,"value":608},"Graviton (CPU)",{"type":45,"tag":183,"props":610,"children":611},{},[612],{"type":50,"value":613},"CPU inference for classical ML",{"type":45,"tag":183,"props":615,"children":616},{},[617],{"type":50,"value":618},"Best price-performance for models that do not need GPU (XGBoost, sklearn, small NLP)",{"type":45,"tag":156,"props":620,"children":621},{},[622,630,635,640],{"type":45,"tag":183,"props":623,"children":624},{},[625],{"type":45,"tag":358,"props":626,"children":627},{},[628],{"type":50,"value":629},"Serverless",{"type":45,"tag":183,"props":631,"children":632},{},[633],{"type":50,"value":634},"Auto-managed",{"type":45,"tag":183,"props":636,"children":637},{},[638],{"type":50,"value":639},"Sporadic or unpredictable traffic",{"type":45,"tag":183,"props":641,"children":642},{},[643],{"type":50,"value":644},"No idle cost; 1-6 GB memory; cold start latency of seconds; max 60s processing time",{"type":45,"tag":313,"props":646,"children":648},{"id":647},"default-to-trainiuminferentia-when-possible",[649],{"type":50,"value":650},"Default to Trainium\u002FInferentia When Possible",{"type":45,"tag":46,"props":652,"children":653},{},[654],{"type":50,"value":655},"Always evaluate ml.trn1 for training and ml.inf2 for inference before selecting GPU instances. Trainium offers up to 50% cost savings for training and Inferentia2 offers 50%+ cost savings for inference on supported model architectures. The AWS Neuron SDK supports PyTorch and TensorFlow natively. Only fall back to GPU instances when the model architecture is not supported by the Neuron compiler (check the Neuron model support matrix) or when the team needs CUDA-specific libraries.",{"type":45,"tag":53,"props":657,"children":659},{"id":658},"inference-deployment-decision-matrix",[660],{"type":50,"value":661},"Inference Deployment Decision Matrix",{"type":45,"tag":148,"props":663,"children":664},{},[665,701],{"type":45,"tag":152,"props":666,"children":667},{},[668],{"type":45,"tag":156,"props":669,"children":670},{},[671,676,681,686,691,696],{"type":45,"tag":160,"props":672,"children":673},{},[674],{"type":50,"value":675},"Pattern",{"type":45,"tag":160,"props":677,"children":678},{},[679],{"type":50,"value":680},"Latency",{"type":45,"tag":160,"props":682,"children":683},{},[684],{"type":50,"value":685},"Max Payload",{"type":45,"tag":160,"props":687,"children":688},{},[689],{"type":50,"value":690},"Timeout",{"type":45,"tag":160,"props":692,"children":693},{},[694],{"type":50,"value":695},"Cost Model",{"type":45,"tag":160,"props":697,"children":698},{},[699],{"type":50,"value":700},"When to Use",{"type":45,"tag":176,"props":702,"children":703},{},[704,740,776,812],{"type":45,"tag":156,"props":705,"children":706},{},[707,715,720,725,730,735],{"type":45,"tag":183,"props":708,"children":709},{},[710],{"type":45,"tag":358,"props":711,"children":712},{},[713],{"type":50,"value":714},"Real-time endpoint",{"type":45,"tag":183,"props":716,"children":717},{},[718],{"type":50,"value":719},"Low (ms)",{"type":45,"tag":183,"props":721,"children":722},{},[723],{"type":50,"value":724},"25 MB",{"type":45,"tag":183,"props":726,"children":727},{},[728],{"type":50,"value":729},"60s (8 min streaming)",{"type":45,"tag":183,"props":731,"children":732},{},[733],{"type":50,"value":734},"Per-instance-hour (always running)",{"type":45,"tag":183,"props":736,"children":737},{},[738],{"type":50,"value":739},"Consistent traffic with latency SLAs; use auto-scaling to match demand",{"type":45,"tag":156,"props":741,"children":742},{},[743,751,756,761,766,771],{"type":45,"tag":183,"props":744,"children":745},{},[746],{"type":45,"tag":358,"props":747,"children":748},{},[749],{"type":50,"value":750},"Serverless inference",{"type":45,"tag":183,"props":752,"children":753},{},[754],{"type":50,"value":755},"Medium (cold start)",{"type":45,"tag":183,"props":757,"children":758},{},[759],{"type":50,"value":760},"4 MB",{"type":45,"tag":183,"props":762,"children":763},{},[764],{"type":50,"value":765},"60s",{"type":45,"tag":183,"props":767,"children":768},{},[769],{"type":50,"value":770},"Per-request + per-ms compute",{"type":45,"tag":183,"props":772,"children":773},{},[774],{"type":50,"value":775},"Sporadic traffic with idle periods; eliminates idle instance cost entirely",{"type":45,"tag":156,"props":777,"children":778},{},[779,787,792,797,802,807],{"type":45,"tag":183,"props":780,"children":781},{},[782],{"type":45,"tag":358,"props":783,"children":784},{},[785],{"type":50,"value":786},"Batch transform",{"type":45,"tag":183,"props":788,"children":789},{},[790],{"type":50,"value":791},"High (minutes-hours)",{"type":45,"tag":183,"props":793,"children":794},{},[795],{"type":50,"value":796},"100 MB\u002Frecord",{"type":45,"tag":183,"props":798,"children":799},{},[800],{"type":50,"value":801},"Days",{"type":45,"tag":183,"props":803,"children":804},{},[805],{"type":50,"value":806},"Per-instance-hour (job duration)",{"type":45,"tag":183,"props":808,"children":809},{},[810],{"type":50,"value":811},"Offline scoring of large datasets; no persistent endpoint needed",{"type":45,"tag":156,"props":813,"children":814},{},[815,823,828,833,838,843],{"type":45,"tag":183,"props":816,"children":817},{},[818],{"type":45,"tag":358,"props":819,"children":820},{},[821],{"type":50,"value":822},"Async inference",{"type":45,"tag":183,"props":824,"children":825},{},[826],{"type":50,"value":827},"Medium-high",{"type":45,"tag":183,"props":829,"children":830},{},[831],{"type":50,"value":832},"1 GB",{"type":45,"tag":183,"props":834,"children":835},{},[836],{"type":50,"value":837},"1 hour",{"type":45,"tag":183,"props":839,"children":840},{},[841],{"type":50,"value":842},"Per-instance-hour (scale to 0)",{"type":45,"tag":183,"props":844,"children":845},{},[846],{"type":50,"value":847},"Large payloads or long processing; queue-based with SNS notifications",{"type":45,"tag":313,"props":849,"children":851},{"id":850},"real-time-endpoint-patterns",[852],{"type":50,"value":853},"Real-time Endpoint Patterns",{"type":45,"tag":855,"props":856,"children":857},"ul",{},[858,868,878,888],{"type":45,"tag":64,"props":859,"children":860},{},[861,866],{"type":45,"tag":358,"props":862,"children":863},{},[864],{"type":50,"value":865},"Single-model endpoint",{"type":50,"value":867},": One model per endpoint. Simplest. Use for most production deployments.",{"type":45,"tag":64,"props":869,"children":870},{},[871,876],{"type":45,"tag":358,"props":872,"children":873},{},[874],{"type":50,"value":875},"Multi-model endpoint (MME)",{"type":50,"value":877},": Thousands of models behind one endpoint, loaded on demand from S3. Use when you have many similar models (per-customer, per-region) and cannot justify an endpoint per model. Trade-off: first-request latency while loading a model.",{"type":45,"tag":64,"props":879,"children":880},{},[881,886],{"type":45,"tag":358,"props":882,"children":883},{},[884],{"type":50,"value":885},"Multi-container endpoint",{"type":50,"value":887},": Up to 15 containers per endpoint, invoked individually or as a serial pipeline. Use for A\u002FB testing different model versions or combining pre\u002Fpost-processing with inference.",{"type":45,"tag":64,"props":889,"children":890},{},[891,896],{"type":45,"tag":358,"props":892,"children":893},{},[894],{"type":50,"value":895},"Shadow testing",{"type":50,"value":897},": Route production traffic to both current and candidate models simultaneously. Compare metrics before promoting. Always use shadow testing before replacing a production model because it reveals performance differences under real traffic that offline evaluation cannot capture.",{"type":45,"tag":313,"props":899,"children":901},{"id":900},"auto-scaling",[902],{"type":50,"value":903},"Auto-Scaling",{"type":45,"tag":46,"props":905,"children":906},{},[907,909,915],{"type":50,"value":908},"Default to target-tracking scaling on ",{"type":45,"tag":75,"props":910,"children":912},{"className":911},[],[913],{"type":50,"value":914},"SageMakerVariantInvocationsPerInstance",{"type":50,"value":916}," because it automatically adjusts instance count based on actual request load without requiring manual threshold tuning.",{"type":45,"tag":918,"props":919,"children":923},"pre",{"className":920,"code":922,"language":50},[921],"language-text","Target value: start at 70% of the max RPS the instance can handle (benchmark first)\nScale-in cooldown: 300 seconds (prevent flapping)\nScale-out cooldown: 60 seconds (respond quickly to load spikes)\n",[924],{"type":45,"tag":75,"props":925,"children":927},{"__ignoreMap":926},"",[928],{"type":50,"value":922},{"type":45,"tag":46,"props":930,"children":931},{},[932],{"type":50,"value":933},"Use Inference Recommender before production deployment to benchmark instance types and find the optimal instance\u002Fmodel combination. It runs load tests and reports latency, throughput, and cost per inference, replacing guesswork with data.",{"type":45,"tag":53,"props":935,"children":937},{"id":936},"sagemaker-pipelines",[938],{"type":50,"value":210},{"type":45,"tag":313,"props":940,"children":942},{"id":941},"pipeline-step-types",[943],{"type":50,"value":944},"Pipeline Step Types",{"type":45,"tag":148,"props":946,"children":947},{},[948,969],{"type":45,"tag":152,"props":949,"children":950},{},[951],{"type":45,"tag":156,"props":952,"children":953},{},[954,959,964],{"type":45,"tag":160,"props":955,"children":956},{},[957],{"type":50,"value":958},"Step",{"type":45,"tag":160,"props":960,"children":961},{},[962],{"type":50,"value":963},"Purpose",{"type":45,"tag":160,"props":965,"children":966},{},[967],{"type":50,"value":968},"Notes",{"type":45,"tag":176,"props":970,"children":971},{},[972,993,1014,1035,1056,1077,1098,1119,1140,1161,1182],{"type":45,"tag":156,"props":973,"children":974},{},[975,983,988],{"type":45,"tag":183,"props":976,"children":977},{},[978],{"type":45,"tag":358,"props":979,"children":980},{},[981],{"type":50,"value":982},"Processing",{"type":45,"tag":183,"props":984,"children":985},{},[986],{"type":50,"value":987},"Data prep, feature engineering, evaluation",{"type":45,"tag":183,"props":989,"children":990},{},[991],{"type":50,"value":992},"Runs a processing container (sklearn, Spark, custom)",{"type":45,"tag":156,"props":994,"children":995},{},[996,1004,1009],{"type":45,"tag":183,"props":997,"children":998},{},[999],{"type":45,"tag":358,"props":1000,"children":1001},{},[1002],{"type":50,"value":1003},"Training",{"type":45,"tag":183,"props":1005,"children":1006},{},[1007],{"type":50,"value":1008},"Model training",{"type":45,"tag":183,"props":1010,"children":1011},{},[1012],{"type":50,"value":1013},"Supports all SageMaker training job features including Spot",{"type":45,"tag":156,"props":1015,"children":1016},{},[1017,1025,1030],{"type":45,"tag":183,"props":1018,"children":1019},{},[1020],{"type":45,"tag":358,"props":1021,"children":1022},{},[1023],{"type":50,"value":1024},"Tuning",{"type":45,"tag":183,"props":1026,"children":1027},{},[1028],{"type":50,"value":1029},"Hyperparameter optimization",{"type":45,"tag":183,"props":1031,"children":1032},{},[1033],{"type":50,"value":1034},"Bayesian, Random, Grid, or Hyperband strategies",{"type":45,"tag":156,"props":1036,"children":1037},{},[1038,1046,1051],{"type":45,"tag":183,"props":1039,"children":1040},{},[1041],{"type":45,"tag":358,"props":1042,"children":1043},{},[1044],{"type":50,"value":1045},"Transform",{"type":45,"tag":183,"props":1047,"children":1048},{},[1049],{"type":50,"value":1050},"Batch inference",{"type":45,"tag":183,"props":1052,"children":1053},{},[1054],{"type":50,"value":1055},"Run batch predictions as a pipeline step",{"type":45,"tag":156,"props":1057,"children":1058},{},[1059,1067,1072],{"type":45,"tag":183,"props":1060,"children":1061},{},[1062],{"type":45,"tag":358,"props":1063,"children":1064},{},[1065],{"type":50,"value":1066},"Model",{"type":45,"tag":183,"props":1068,"children":1069},{},[1070],{"type":50,"value":1071},"Create\u002Fregister model",{"type":45,"tag":183,"props":1073,"children":1074},{},[1075],{"type":50,"value":1076},"Register in Model Registry with metadata",{"type":45,"tag":156,"props":1078,"children":1079},{},[1080,1088,1093],{"type":45,"tag":183,"props":1081,"children":1082},{},[1083],{"type":45,"tag":358,"props":1084,"children":1085},{},[1086],{"type":50,"value":1087},"Condition",{"type":45,"tag":183,"props":1089,"children":1090},{},[1091],{"type":50,"value":1092},"Branching logic",{"type":45,"tag":183,"props":1094,"children":1095},{},[1096],{"type":50,"value":1097},"Route pipeline based on metrics (e.g., accuracy threshold)",{"type":45,"tag":156,"props":1099,"children":1100},{},[1101,1109,1114],{"type":45,"tag":183,"props":1102,"children":1103},{},[1104],{"type":45,"tag":358,"props":1105,"children":1106},{},[1107],{"type":50,"value":1108},"Callback",{"type":45,"tag":183,"props":1110,"children":1111},{},[1112],{"type":50,"value":1113},"External integration",{"type":45,"tag":183,"props":1115,"children":1116},{},[1117],{"type":50,"value":1118},"Wait for external approval or process completion",{"type":45,"tag":156,"props":1120,"children":1121},{},[1122,1130,1135],{"type":45,"tag":183,"props":1123,"children":1124},{},[1125],{"type":45,"tag":358,"props":1126,"children":1127},{},[1128],{"type":50,"value":1129},"Lambda",{"type":45,"tag":183,"props":1131,"children":1132},{},[1133],{"type":50,"value":1134},"Run a Lambda function",{"type":45,"tag":183,"props":1136,"children":1137},{},[1138],{"type":50,"value":1139},"Lightweight compute for custom logic",{"type":45,"tag":156,"props":1141,"children":1142},{},[1143,1151,1156],{"type":45,"tag":183,"props":1144,"children":1145},{},[1146],{"type":45,"tag":358,"props":1147,"children":1148},{},[1149],{"type":50,"value":1150},"QualityCheck",{"type":45,"tag":183,"props":1152,"children":1153},{},[1154],{"type":50,"value":1155},"Data\u002Fmodel quality check",{"type":45,"tag":183,"props":1157,"children":1158},{},[1159],{"type":50,"value":1160},"Integrates with Model Monitor baselines",{"type":45,"tag":156,"props":1162,"children":1163},{},[1164,1172,1177],{"type":45,"tag":183,"props":1165,"children":1166},{},[1167],{"type":45,"tag":358,"props":1168,"children":1169},{},[1170],{"type":50,"value":1171},"ClarifyCheck",{"type":45,"tag":183,"props":1173,"children":1174},{},[1175],{"type":50,"value":1176},"Bias and explainability",{"type":45,"tag":183,"props":1178,"children":1179},{},[1180],{"type":50,"value":1181},"Integrates with SageMaker Clarify",{"type":45,"tag":156,"props":1183,"children":1184},{},[1185,1193,1198],{"type":45,"tag":183,"props":1186,"children":1187},{},[1188],{"type":45,"tag":358,"props":1189,"children":1190},{},[1191],{"type":50,"value":1192},"Fail",{"type":45,"tag":183,"props":1194,"children":1195},{},[1196],{"type":50,"value":1197},"Terminate with error",{"type":45,"tag":183,"props":1199,"children":1200},{},[1201],{"type":50,"value":1202},"Explicit failure with message for debugging",{"type":45,"tag":313,"props":1204,"children":1206},{"id":1205},"model-registry",[1207],{"type":50,"value":1208},"Model Registry",{"type":45,"tag":46,"props":1210,"children":1211},{},[1212],{"type":50,"value":1213},"The Model Registry is the central artifact store for production ML. Always register models through the registry because it provides:",{"type":45,"tag":855,"props":1215,"children":1216},{},[1217,1227,1237,1247],{"type":45,"tag":64,"props":1218,"children":1219},{},[1220,1225],{"type":45,"tag":358,"props":1221,"children":1222},{},[1223],{"type":50,"value":1224},"Version tracking",{"type":50,"value":1226},": Every model gets an immutable version number with metadata (metrics, parameters, data lineage)",{"type":45,"tag":64,"props":1228,"children":1229},{},[1230,1235],{"type":45,"tag":358,"props":1231,"children":1232},{},[1233],{"type":50,"value":1234},"Approval workflows",{"type":50,"value":1236},": Models must be explicitly approved (manual or automated) before deployment, preventing untested models from reaching production",{"type":45,"tag":64,"props":1238,"children":1239},{},[1240,1245],{"type":45,"tag":358,"props":1241,"children":1242},{},[1243],{"type":50,"value":1244},"Lineage",{"type":50,"value":1246},": Links model versions to the training job, dataset, pipeline execution, and code commit that produced them",{"type":45,"tag":64,"props":1248,"children":1249},{},[1250,1255],{"type":45,"tag":358,"props":1251,"children":1252},{},[1253],{"type":50,"value":1254},"Cross-account deployment",{"type":50,"value":1256},": Approved models can be deployed to staging\u002Fproduction accounts via resource policies",{"type":45,"tag":313,"props":1258,"children":1260},{"id":1259},"pipeline-best-practices",[1261],{"type":50,"value":1262},"Pipeline Best Practices",{"type":45,"tag":855,"props":1264,"children":1265},{},[1266,1276,1286,1296],{"type":45,"tag":64,"props":1267,"children":1268},{},[1269,1274],{"type":45,"tag":358,"props":1270,"children":1271},{},[1272],{"type":50,"value":1273},"Parameterize everything",{"type":50,"value":1275},": Instance types, data paths, hyperparameters, and thresholds should be pipeline parameters, not hardcoded values. This enables reuse across environments (dev\u002Fstaging\u002Fprod) without code changes.",{"type":45,"tag":64,"props":1277,"children":1278},{},[1279,1284],{"type":45,"tag":358,"props":1280,"children":1281},{},[1282],{"type":50,"value":1283},"Use Condition steps for quality gates",{"type":50,"value":1285},": After training, compare the candidate model metric against a threshold. Only register and deploy if the metric passes. This prevents model regressions from reaching production.",{"type":45,"tag":64,"props":1287,"children":1288},{},[1289,1294],{"type":45,"tag":358,"props":1290,"children":1291},{},[1292],{"type":50,"value":1293},"Cache pipeline steps",{"type":50,"value":1295},": Enable step caching to skip unchanged steps on re-execution, reducing pipeline run time and cost.",{"type":45,"tag":64,"props":1297,"children":1298},{},[1299,1304],{"type":45,"tag":358,"props":1300,"children":1301},{},[1302],{"type":50,"value":1303},"Trigger pipelines from CI\u002FCD",{"type":50,"value":1305},": Use CodePipeline or GitHub Actions to trigger SageMaker Pipelines on code merge, creating a full ML CI\u002FCD loop.",{"type":45,"tag":53,"props":1307,"children":1309},{"id":1308},"mlflow-on-aws",[1310],{"type":50,"value":1311},"MLflow on AWS",{"type":45,"tag":313,"props":1313,"children":1315},{"id":1314},"managed-mlflow-on-sagemaker-recommended-default",[1316],{"type":50,"value":1317},"Managed MLflow on SageMaker (Recommended Default)",{"type":45,"tag":46,"props":1319,"children":1320},{},[1321],{"type":50,"value":1322},"Use managed MLflow on SageMaker as the default experiment tracking solution because it requires zero infrastructure management, scales automatically, and synchronizes with SageMaker Model Registry automatically.",{"type":45,"tag":855,"props":1324,"children":1325},{},[1326,1336,1346,1351,1356,1361],{"type":45,"tag":64,"props":1327,"children":1328},{},[1329,1334],{"type":45,"tag":358,"props":1330,"children":1331},{},[1332],{"type":50,"value":1333},"MLflow Apps",{"type":50,"value":1335},": Latest offering with faster startup, cross-account sharing, and automatic model registration",{"type":45,"tag":64,"props":1337,"children":1338},{},[1339,1344],{"type":45,"tag":358,"props":1340,"children":1341},{},[1342],{"type":50,"value":1343},"MLflow Tracking Servers",{"type":50,"value":1345},": Traditional MLflow with configurable compute and storage; each project can have its own server",{"type":45,"tag":64,"props":1347,"children":1348},{},[1349],{"type":50,"value":1350},"Artifacts stored in S3 (durable, shareable, versioned)",{"type":45,"tag":64,"props":1352,"children":1353},{},[1354],{"type":50,"value":1355},"Native integration with SageMaker training jobs — metrics logged automatically",{"type":45,"tag":64,"props":1357,"children":1358},{},[1359],{"type":50,"value":1360},"Models registered in MLflow automatically appear in SageMaker Model Registry",{"type":45,"tag":64,"props":1362,"children":1363},{},[1364],{"type":50,"value":1365},"Deploy MLflow models directly to SageMaker endpoints without custom containers",{"type":45,"tag":313,"props":1367,"children":1369},{"id":1368},"self-hosted-mlflow-on-eks",[1370],{"type":50,"value":1371},"Self-Hosted MLflow on EKS",{"type":45,"tag":46,"props":1373,"children":1374},{},[1375],{"type":50,"value":1376},"Only choose self-hosted MLflow when you need custom plugins, specific MLflow versions not yet supported by the managed service, or multi-cloud portability with a single MLflow backend.",{"type":45,"tag":855,"props":1378,"children":1379},{},[1380,1385,1390,1395,1400],{"type":45,"tag":64,"props":1381,"children":1382},{},[1383],{"type":50,"value":1384},"Deploy MLflow server as a Kubernetes Deployment on EKS",{"type":45,"tag":64,"props":1386,"children":1387},{},[1388],{"type":50,"value":1389},"Use Amazon RDS (PostgreSQL) as the metadata\u002Fbackend store for durability and query performance",{"type":45,"tag":64,"props":1391,"children":1392},{},[1393],{"type":50,"value":1394},"Use S3 as the artifact store with a dedicated bucket and lifecycle policies",{"type":45,"tag":64,"props":1396,"children":1397},{},[1398],{"type":50,"value":1399},"Front with an ALB + Cognito or IAM for authentication",{"type":45,"tag":64,"props":1401,"children":1402},{},[1403],{"type":50,"value":1404},"Operational overhead: you own patching, scaling, backups, and availability",{"type":45,"tag":313,"props":1406,"children":1408},{"id":1407},"when-to-choose-mlflow-over-native-sagemaker-experiments",[1409],{"type":50,"value":1410},"When to Choose MLflow over Native SageMaker Experiments",{"type":45,"tag":855,"props":1412,"children":1413},{},[1414,1419,1424,1429],{"type":45,"tag":64,"props":1415,"children":1416},{},[1417],{"type":50,"value":1418},"Team has existing MLflow workflows and muscle memory",{"type":45,"tag":64,"props":1420,"children":1421},{},[1422],{"type":50,"value":1423},"Multi-cloud or hybrid-cloud requirement where portability matters",{"type":45,"tag":64,"props":1425,"children":1426},{},[1427],{"type":50,"value":1428},"Need for MLflow-specific features (Prompt Registry, advanced tracing for agentic workflows)",{"type":45,"tag":64,"props":1430,"children":1431},{},[1432],{"type":50,"value":1433},"Want a single UI for experiment comparison across SageMaker and non-SageMaker training runs",{"type":45,"tag":53,"props":1435,"children":1437},{"id":1436},"model-monitoring",[1438],{"type":50,"value":1439},"Model Monitoring",{"type":45,"tag":313,"props":1441,"children":1443},{"id":1442},"four-monitoring-dimensions",[1444],{"type":50,"value":1445},"Four Monitoring Dimensions",{"type":45,"tag":148,"props":1447,"children":1448},{},[1449,1474],{"type":45,"tag":152,"props":1450,"children":1451},{},[1452],{"type":45,"tag":156,"props":1453,"children":1454},{},[1455,1460,1465,1470],{"type":45,"tag":160,"props":1456,"children":1457},{},[1458],{"type":50,"value":1459},"Monitor Type",{"type":45,"tag":160,"props":1461,"children":1462},{},[1463],{"type":50,"value":1464},"What It Detects",{"type":45,"tag":160,"props":1466,"children":1467},{},[1468],{"type":50,"value":1469},"Baseline Source",{"type":45,"tag":160,"props":1471,"children":1472},{},[1473],{"type":50,"value":700},{"type":45,"tag":176,"props":1475,"children":1476},{},[1477,1503,1529,1555],{"type":45,"tag":156,"props":1478,"children":1479},{},[1480,1488,1493,1498],{"type":45,"tag":183,"props":1481,"children":1482},{},[1483],{"type":45,"tag":358,"props":1484,"children":1485},{},[1486],{"type":50,"value":1487},"Data Quality",{"type":45,"tag":183,"props":1489,"children":1490},{},[1491],{"type":50,"value":1492},"Schema violations, missing values, statistical drift in input features",{"type":45,"tag":183,"props":1494,"children":1495},{},[1496],{"type":50,"value":1497},"Training dataset statistics",{"type":45,"tag":183,"props":1499,"children":1500},{},[1501],{"type":50,"value":1502},"Always — this is the earliest signal that something changed",{"type":45,"tag":156,"props":1504,"children":1505},{},[1506,1514,1519,1524],{"type":45,"tag":183,"props":1507,"children":1508},{},[1509],{"type":45,"tag":358,"props":1510,"children":1511},{},[1512],{"type":50,"value":1513},"Model Quality",{"type":45,"tag":183,"props":1515,"children":1516},{},[1517],{"type":50,"value":1518},"Accuracy\u002Fprecision\u002Frecall\u002FRMSE degradation",{"type":45,"tag":183,"props":1520,"children":1521},{},[1522],{"type":50,"value":1523},"Baseline predictions + ground truth",{"type":45,"tag":183,"props":1525,"children":1526},{},[1527],{"type":50,"value":1528},"When ground truth labels are available (even delayed)",{"type":45,"tag":156,"props":1530,"children":1531},{},[1532,1540,1545,1550],{"type":45,"tag":183,"props":1533,"children":1534},{},[1535],{"type":45,"tag":358,"props":1536,"children":1537},{},[1538],{"type":50,"value":1539},"Bias Drift",{"type":45,"tag":183,"props":1541,"children":1542},{},[1543],{"type":50,"value":1544},"Changes in model fairness across demographic groups",{"type":45,"tag":183,"props":1546,"children":1547},{},[1548],{"type":50,"value":1549},"Pre-deployment bias metrics from Clarify",{"type":45,"tag":183,"props":1551,"children":1552},{},[1553],{"type":50,"value":1554},"When the model makes decisions affecting people (lending, hiring, content)",{"type":45,"tag":156,"props":1556,"children":1557},{},[1558,1566,1571,1576],{"type":45,"tag":183,"props":1559,"children":1560},{},[1561],{"type":45,"tag":358,"props":1562,"children":1563},{},[1564],{"type":50,"value":1565},"Feature Attribution Drift",{"type":45,"tag":183,"props":1567,"children":1568},{},[1569],{"type":50,"value":1570},"Shifts in which features drive predictions",{"type":45,"tag":183,"props":1572,"children":1573},{},[1574],{"type":50,"value":1575},"SHAP values from Clarify baseline",{"type":45,"tag":183,"props":1577,"children":1578},{},[1579],{"type":50,"value":1580},"When you need to explain why predictions changed, not just that they changed",{"type":45,"tag":313,"props":1582,"children":1584},{"id":1583},"monitoring-setup",[1585],{"type":50,"value":1586},"Monitoring Setup",{"type":45,"tag":60,"props":1588,"children":1589},{},[1590,1600,1626,1636,1646],{"type":45,"tag":64,"props":1591,"children":1592},{},[1593,1598],{"type":45,"tag":358,"props":1594,"children":1595},{},[1596],{"type":50,"value":1597},"Enable Data Capture",{"type":50,"value":1599}," on the endpoint to log inputs and outputs to S3 (asynchronous, no performance impact on inference)",{"type":45,"tag":64,"props":1601,"children":1602},{},[1603,1608,1610,1616,1618,1624],{"type":45,"tag":358,"props":1604,"children":1605},{},[1606],{"type":50,"value":1607},"Create baselines",{"type":50,"value":1609}," from the training dataset using ",{"type":45,"tag":75,"props":1611,"children":1613},{"className":1612},[],[1614],{"type":50,"value":1615},"DefaultModelMonitor",{"type":50,"value":1617}," for data quality or ",{"type":45,"tag":75,"props":1619,"children":1621},{"className":1620},[],[1622],{"type":50,"value":1623},"ModelQualityMonitor",{"type":50,"value":1625}," for model quality",{"type":45,"tag":64,"props":1627,"children":1628},{},[1629,1634],{"type":45,"tag":358,"props":1630,"children":1631},{},[1632],{"type":50,"value":1633},"Schedule monitoring jobs",{"type":50,"value":1635}," — hourly for high-traffic endpoints, daily for moderate traffic",{"type":45,"tag":64,"props":1637,"children":1638},{},[1639,1644],{"type":45,"tag":358,"props":1640,"children":1641},{},[1642],{"type":50,"value":1643},"Configure CloudWatch alarms",{"type":50,"value":1645}," on monitoring violations to trigger SNS notifications",{"type":45,"tag":64,"props":1647,"children":1648},{},[1649,1654],{"type":45,"tag":358,"props":1650,"children":1651},{},[1652],{"type":50,"value":1653},"Automate retraining",{"type":50,"value":1655},": Use EventBridge to trigger a SageMaker Pipeline re-execution when monitoring detects sustained drift",{"type":45,"tag":313,"props":1657,"children":1659},{"id":1658},"when-to-retrain-vs-when-to-investigate",[1660],{"type":50,"value":1661},"When to Retrain vs When to Investigate",{"type":45,"tag":855,"props":1663,"children":1664},{},[1665,1675],{"type":45,"tag":64,"props":1666,"children":1667},{},[1668,1673],{"type":45,"tag":358,"props":1669,"children":1670},{},[1671],{"type":50,"value":1672},"Retrain",{"type":50,"value":1674}," when data quality monitoring shows gradual statistical drift (feature distributions shifting over time) and the model's accuracy metrics are declining — this is expected model staleness",{"type":45,"tag":64,"props":1676,"children":1677},{},[1678,1683],{"type":45,"tag":358,"props":1679,"children":1680},{},[1681],{"type":50,"value":1682},"Investigate first",{"type":50,"value":1684}," when monitoring shows sudden, sharp changes — this typically indicates an upstream data pipeline issue, a schema change, or a bug, not genuine drift; retraining on bad data makes things worse",{"type":45,"tag":53,"props":1686,"children":1688},{"id":1687},"distributed-training",[1689],{"type":50,"value":1690},"Distributed Training",{"type":45,"tag":313,"props":1692,"children":1694},{"id":1693},"data-parallel",[1695],{"type":50,"value":1696},"Data Parallel",{"type":45,"tag":46,"props":1698,"children":1699},{},[1700],{"type":50,"value":1701},"Use data parallel training when the model fits in a single GPU's memory but training is slow due to dataset size. Each GPU processes a different data batch, gradients are synchronized across GPUs. SageMaker's distributed data parallelism (SMDDP) library optimizes AllReduce\u002FAllGather operations for better inter-node communication.",{"type":45,"tag":313,"props":1703,"children":1705},{"id":1704},"model-parallel",[1706],{"type":50,"value":1707},"Model Parallel",{"type":45,"tag":46,"props":1709,"children":1710},{},[1711],{"type":50,"value":1712},"Use model parallel training when the model does not fit in a single GPU's memory (large language models, large vision transformers). SageMaker's model parallelism (SMP) library supports tensor parallelism, pipeline parallelism, and expert parallelism. Use EFA-enabled instances (ml.p4d, ml.p5, ml.trn1) for model parallel training because inter-node communication is the bottleneck and EFA provides 400-3200 Gbps networking.",{"type":45,"tag":313,"props":1714,"children":1716},{"id":1715},"hyperparameter-tuning-strategies",[1717],{"type":50,"value":1718},"Hyperparameter Tuning Strategies",{"type":45,"tag":148,"props":1720,"children":1721},{},[1722,1741],{"type":45,"tag":152,"props":1723,"children":1724},{},[1725],{"type":45,"tag":156,"props":1726,"children":1727},{},[1728,1733,1737],{"type":45,"tag":160,"props":1729,"children":1730},{},[1731],{"type":50,"value":1732},"Strategy",{"type":45,"tag":160,"props":1734,"children":1735},{},[1736],{"type":50,"value":700},{"type":45,"tag":160,"props":1738,"children":1739},{},[1740],{"type":50,"value":968},{"type":45,"tag":176,"props":1742,"children":1743},{},[1744,1767,1788,1809],{"type":45,"tag":156,"props":1745,"children":1746},{},[1747,1757,1762],{"type":45,"tag":183,"props":1748,"children":1749},{},[1750,1755],{"type":45,"tag":358,"props":1751,"children":1752},{},[1753],{"type":50,"value":1754},"Bayesian",{"type":50,"value":1756}," (default)",{"type":45,"tag":183,"props":1758,"children":1759},{},[1760],{"type":50,"value":1761},"Most cases",{"type":45,"tag":183,"props":1763,"children":1764},{},[1765],{"type":50,"value":1766},"Uses prior results to choose next trials; converges faster with fewer trials",{"type":45,"tag":156,"props":1768,"children":1769},{},[1770,1778,1783],{"type":45,"tag":183,"props":1771,"children":1772},{},[1773],{"type":45,"tag":358,"props":1774,"children":1775},{},[1776],{"type":50,"value":1777},"Random",{"type":45,"tag":183,"props":1779,"children":1780},{},[1781],{"type":50,"value":1782},"Large search spaces with many parameters",{"type":45,"tag":183,"props":1784,"children":1785},{},[1786],{"type":50,"value":1787},"Good baseline; easy to parallelize",{"type":45,"tag":156,"props":1789,"children":1790},{},[1791,1799,1804],{"type":45,"tag":183,"props":1792,"children":1793},{},[1794],{"type":45,"tag":358,"props":1795,"children":1796},{},[1797],{"type":50,"value":1798},"Grid",{"type":45,"tag":183,"props":1800,"children":1801},{},[1802],{"type":50,"value":1803},"Small discrete search spaces",{"type":45,"tag":183,"props":1805,"children":1806},{},[1807],{"type":50,"value":1808},"Exhaustive; only practical with few parameters and few values each",{"type":45,"tag":156,"props":1810,"children":1811},{},[1812,1820,1825],{"type":45,"tag":183,"props":1813,"children":1814},{},[1815],{"type":45,"tag":358,"props":1816,"children":1817},{},[1818],{"type":50,"value":1819},"Hyperband",{"type":45,"tag":183,"props":1821,"children":1822},{},[1823],{"type":50,"value":1824},"Need results fast on a budget",{"type":45,"tag":183,"props":1826,"children":1827},{},[1828],{"type":50,"value":1829},"Early-stops poor configurations; allocates more resources to promising ones",{"type":45,"tag":46,"props":1831,"children":1832},{},[1833],{"type":50,"value":1834},"Always use Bayesian optimization as the default because it typically finds better hyperparameters in fewer trials than random search, directly reducing training cost.",{"type":45,"tag":53,"props":1836,"children":1838},{"id":1837},"cost-optimization",[1839],{"type":50,"value":1840},"Cost Optimization",{"type":45,"tag":313,"props":1842,"children":1844},{"id":1843},"managed-spot-training",[1845],{"type":50,"value":1846},"Managed Spot Training",{"type":45,"tag":46,"props":1848,"children":1849},{},[1850],{"type":50,"value":1851},"Always use Managed Spot Training for training jobs because training is inherently fault-tolerant (checkpointing lets you resume from the last saved state) and Spot provides 60-90% savings over On-Demand. The only exception is ultra-time-sensitive training where any interruption is unacceptable (rare in practice).",{"type":45,"tag":855,"props":1853,"children":1854},{},[1855,1868,1881,1886],{"type":45,"tag":64,"props":1856,"children":1857},{},[1858,1860,1866],{"type":50,"value":1859},"Enable with ",{"type":45,"tag":75,"props":1861,"children":1863},{"className":1862},[],[1864],{"type":50,"value":1865},"use_spot_instances=True",{"type":50,"value":1867}," in the Estimator",{"type":45,"tag":64,"props":1869,"children":1870},{},[1871,1873,1879],{"type":50,"value":1872},"Set ",{"type":45,"tag":75,"props":1874,"children":1876},{"className":1875},[],[1877],{"type":50,"value":1878},"max_wait",{"type":50,"value":1880}," to 2x the expected training time to allow for interruptions",{"type":45,"tag":64,"props":1882,"children":1883},{},[1884],{"type":50,"value":1885},"Enable checkpointing to S3 so training resumes from the last checkpoint, not from scratch",{"type":45,"tag":64,"props":1887,"children":1888},{},[1889],{"type":50,"value":1890},"SageMaker automatically handles Spot interruption, checkpoint save, and job restart",{"type":45,"tag":313,"props":1892,"children":1894},{"id":1893},"sagemaker-savings-plans",[1895],{"type":50,"value":1896},"SageMaker Savings Plans",{"type":45,"tag":46,"props":1898,"children":1899},{},[1900],{"type":50,"value":1901},"Commit to consistent SageMaker usage (measured in $\u002Fhour) for 1 or 3 years. Savings Plans cover Studio Notebooks, Processing, Training, Real-Time Inference, and Batch Transform. Up to 64% savings over On-Demand. Use for production inference endpoints that run continuously.",{"type":45,"tag":313,"props":1903,"children":1905},{"id":1904},"serverless-inference-for-sporadic-traffic",[1906],{"type":50,"value":1907},"Serverless Inference for Sporadic Traffic",{"type":45,"tag":46,"props":1909,"children":1910},{},[1911],{"type":50,"value":1912},"Use Serverless Inference instead of real-time endpoints when traffic is sporadic or unpredictable. Real-time endpoints charge per instance-hour even when idle; Serverless charges per request and per millisecond of compute. A real-time ml.m5.large endpoint costs ~$100\u002Fmonth idle. Serverless at 100 requests\u002Fday costs under $5\u002Fmonth.",{"type":45,"tag":313,"props":1914,"children":1916},{"id":1915},"instance-right-sizing-with-inference-recommender",[1917],{"type":50,"value":1918},"Instance Right-Sizing with Inference Recommender",{"type":45,"tag":46,"props":1920,"children":1921},{},[1922],{"type":50,"value":1923},"Run SageMaker Inference Recommender before deploying to production. It benchmarks your model across instance types and reports latency percentiles, throughput, and cost per inference. Teams that skip this step typically overprovision by 2-3x because they guess conservatively.",{"type":45,"tag":313,"props":1925,"children":1927},{"id":1926},"trainium-and-inferentia",[1928],{"type":50,"value":1929},"Trainium and Inferentia",{"type":45,"tag":46,"props":1931,"children":1932},{},[1933],{"type":50,"value":1934},"Evaluate Trainium (ml.trn1) for training and Inferentia2 (ml.inf2) for inference on every ML project. For supported model architectures (most PyTorch and TensorFlow models), these custom silicon instances deliver 50%+ cost savings compared to GPU instances. The Neuron SDK compiles models for these chips with minimal code changes. Only skip when the model uses CUDA-specific operations that Neuron does not support.",{"type":45,"tag":53,"props":1936,"children":1938},{"id":1937},"anti-patterns",[1939],{"type":50,"value":1940},"Anti-Patterns",{"type":45,"tag":855,"props":1942,"children":1943},{},[1944,1954,1964,1974,1984,1994,2004,2014,2024,2034,2044,2054],{"type":45,"tag":64,"props":1945,"children":1946},{},[1947,1952],{"type":45,"tag":358,"props":1948,"children":1949},{},[1950],{"type":50,"value":1951},"Training on notebooks instead of training jobs.",{"type":50,"value":1953}," Notebook training is not reproducible, cannot use Spot instances (60-90% savings lost), cannot distribute across multiple instances, and produces no training job metadata for lineage tracking. Always convert notebook experiments to SageMaker Training Jobs for anything beyond initial prototyping.",{"type":45,"tag":64,"props":1955,"children":1956},{},[1957,1962],{"type":45,"tag":358,"props":1958,"children":1959},{},[1960],{"type":50,"value":1961},"Skipping Model Registry.",{"type":50,"value":1963}," Without a registry, there is no version history, no approval workflow, no lineage from model to training data, and no clean rollback path. A bad model deployed without registry tracking requires manual forensics to identify what changed.",{"type":45,"tag":64,"props":1965,"children":1966},{},[1967,1972],{"type":45,"tag":358,"props":1968,"children":1969},{},[1970],{"type":50,"value":1971},"Real-time endpoints for batch workloads.",{"type":50,"value":1973}," A real-time endpoint running 24\u002F7 to process a nightly batch job wastes money on 23 hours of idle compute. Batch Transform provisions instances only for the job duration and terminates them automatically.",{"type":45,"tag":64,"props":1975,"children":1976},{},[1977,1982],{"type":45,"tag":358,"props":1978,"children":1979},{},[1980],{"type":50,"value":1981},"Single large instance instead of distributed training.",{"type":50,"value":1983}," A single ml.p5.48xlarge costs more per hour than multiple smaller instances delivering equivalent total compute. Distributed training also provides fault tolerance — if one node fails, only that node's work is lost, not the entire job.",{"type":45,"tag":64,"props":1985,"children":1986},{},[1987,1992],{"type":45,"tag":358,"props":1988,"children":1989},{},[1990],{"type":50,"value":1991},"No model monitoring after deployment.",{"type":50,"value":1993}," Without monitoring, model drift goes undetected. Predictions degrade silently, and the team only discovers the problem when business metrics drop — weeks or months later. Data quality monitoring catches drift within hours.",{"type":45,"tag":64,"props":1995,"children":1996},{},[1997,2002],{"type":45,"tag":358,"props":1998,"children":1999},{},[2000],{"type":50,"value":2001},"On-Demand training instances by default.",{"type":50,"value":2003}," SageMaker Managed Spot Training saves 60-90% and handles interruptions automatically with checkpointing. Training jobs are inherently resumable, making them ideal Spot workloads. On-Demand should be the exception, not the default.",{"type":45,"tag":64,"props":2005,"children":2006},{},[2007,2012],{"type":45,"tag":358,"props":2008,"children":2009},{},[2010],{"type":50,"value":2011},"Deploying directly to production without shadow testing.",{"type":50,"value":2013}," Shadow testing routes live traffic to both the current and candidate models, comparing predictions and latency in real-time. Without it, the only signal that a new model is worse comes from production users experiencing degraded results.",{"type":45,"tag":64,"props":2015,"children":2016},{},[2017,2022],{"type":45,"tag":358,"props":2018,"children":2019},{},[2020],{"type":50,"value":2021},"Not using experiment tracking (MLflow or SageMaker Experiments).",{"type":50,"value":2023}," Without experiment tracking, it is impossible to reproduce a previous result, compare hyperparameter choices across runs, or explain why one model version outperformed another. This wastes compute re-running experiments that were already tried.",{"type":45,"tag":64,"props":2025,"children":2026},{},[2027,2032],{"type":45,"tag":358,"props":2028,"children":2029},{},[2030],{"type":50,"value":2031},"Storing artifacts locally instead of S3.",{"type":50,"value":2033}," Local artifacts are not durable (instance termination deletes them), not shareable across team members, and break CI\u002FCD pipelines that expect S3 paths. S3 provides versioning, cross-account access, and lifecycle management.",{"type":45,"tag":64,"props":2035,"children":2036},{},[2037,2042],{"type":45,"tag":358,"props":2038,"children":2039},{},[2040],{"type":50,"value":2041},"Ignoring Trainium\u002FInferentia.",{"type":50,"value":2043}," ml.trn1 and ml.inf2 instances deliver 50%+ cost savings for supported model architectures. Teams that default to GPU without evaluating Neuron compatibility leave significant savings on the table. The Neuron SDK supports PyTorch and TensorFlow natively with minimal code changes.",{"type":45,"tag":64,"props":2045,"children":2046},{},[2047,2052],{"type":45,"tag":358,"props":2048,"children":2049},{},[2050],{"type":50,"value":2051},"Hardcoding instance types and hyperparameters in pipeline definitions.",{"type":50,"value":2053}," Non-parameterized pipelines cannot be reused across environments (dev\u002Fstaging\u002Fprod) and require code changes for every configuration adjustment. Use SageMaker Pipeline parameters for all configurable values.",{"type":45,"tag":64,"props":2055,"children":2056},{},[2057,2062],{"type":45,"tag":358,"props":2058,"children":2059},{},[2060],{"type":50,"value":2061},"Manual model deployment without CI\u002FCD.",{"type":50,"value":2063}," Manual deployments are error-prone, unauditable, and slow. Use SageMaker Pipelines or CodePipeline to automate the path from model registration to staging to production, with approval gates at each stage.",{"type":45,"tag":53,"props":2065,"children":2067},{"id":2066},"additional-resources",[2068],{"type":50,"value":2069},"Additional Resources",{"type":45,"tag":313,"props":2071,"children":2073},{"id":2072},"reference-files",[2074],{"type":50,"value":2075},"Reference Files",{"type":45,"tag":46,"props":2077,"children":2078},{},[2079],{"type":50,"value":2080},"For detailed configurations, CLI commands, and code examples, consult:",{"type":45,"tag":855,"props":2082,"children":2083},{},[2084,2098,2112],{"type":45,"tag":64,"props":2085,"children":2086},{},[2087,2096],{"type":45,"tag":358,"props":2088,"children":2089},{},[2090],{"type":45,"tag":75,"props":2091,"children":2093},{"className":2092},[],[2094],{"type":50,"value":2095},"references\u002Ftraining-patterns.md",{"type":50,"value":2097}," — Training job configurations (single-instance, distributed, Spot), hyperparameter tuning setup, checkpointing, SageMaker Processing examples, and distributed training strategies",{"type":45,"tag":64,"props":2099,"children":2100},{},[2101,2110],{"type":45,"tag":358,"props":2102,"children":2103},{},[2104],{"type":45,"tag":75,"props":2105,"children":2107},{"className":2106},[],[2108],{"type":50,"value":2109},"references\u002Finference-deployment.md",{"type":50,"value":2111}," — Real-time endpoint configurations, serverless inference, batch transform, async inference, auto-scaling policies, multi-model endpoints, shadow testing, and Inference Recommender usage",{"type":45,"tag":64,"props":2113,"children":2114},{},[2115,2124],{"type":45,"tag":358,"props":2116,"children":2117},{},[2118],{"type":45,"tag":75,"props":2119,"children":2121},{"className":2120},[],[2122],{"type":50,"value":2123},"references\u002Fpipeline-recipes.md",{"type":50,"value":2125}," — SageMaker Pipeline definitions (Python SDK), Model Registry workflows, CI\u002FCD integration with CodePipeline, MLflow experiment tracking setup, and monitoring configuration",{"type":45,"tag":313,"props":2127,"children":2129},{"id":2128},"related-skills",[2130],{"type":50,"value":2131},"Related Skills",{"type":45,"tag":855,"props":2133,"children":2134},{},[2135,2149,2163,2177,2191,2205,2219,2233,2247],{"type":45,"tag":64,"props":2136,"children":2137},{},[2138,2147],{"type":45,"tag":358,"props":2139,"children":2140},{},[2141],{"type":45,"tag":75,"props":2142,"children":2144},{"className":2143},[],[2145],{"type":50,"value":2146},"bedrock",{"type":50,"value":2148}," — Foundation model customization, fine-tuning, and Bedrock-native inference",{"type":45,"tag":64,"props":2150,"children":2151},{},[2152,2161],{"type":45,"tag":358,"props":2153,"children":2154},{},[2155],{"type":45,"tag":75,"props":2156,"children":2158},{"className":2157},[],[2159],{"type":50,"value":2160},"eks",{"type":50,"value":2162}," — Kubernetes cluster design for Kubeflow or self-hosted MLflow deployments",{"type":45,"tag":64,"props":2164,"children":2165},{},[2166,2175],{"type":45,"tag":358,"props":2167,"children":2168},{},[2169],{"type":45,"tag":75,"props":2170,"children":2172},{"className":2171},[],[2173],{"type":50,"value":2174},"lambda",{"type":50,"value":2176}," — Serverless compute for lightweight ML inference or pipeline triggers",{"type":45,"tag":64,"props":2178,"children":2179},{},[2180,2189],{"type":45,"tag":358,"props":2181,"children":2182},{},[2183],{"type":45,"tag":75,"props":2184,"children":2186},{"className":2185},[],[2187],{"type":50,"value":2188},"step-functions",{"type":50,"value":2190}," — Workflow orchestration for simple ML pipelines without SageMaker Pipelines",{"type":45,"tag":64,"props":2192,"children":2193},{},[2194,2203],{"type":45,"tag":358,"props":2195,"children":2196},{},[2197],{"type":45,"tag":75,"props":2198,"children":2200},{"className":2199},[],[2201],{"type":50,"value":2202},"s3",{"type":50,"value":2204}," — Data lake design, artifact storage, lifecycle policies for training data and model artifacts",{"type":45,"tag":64,"props":2206,"children":2207},{},[2208,2217],{"type":45,"tag":358,"props":2209,"children":2210},{},[2211],{"type":45,"tag":75,"props":2212,"children":2214},{"className":2213},[],[2215],{"type":50,"value":2216},"iam",{"type":50,"value":2218}," — Least-privilege roles for SageMaker execution, cross-account model deployment",{"type":45,"tag":64,"props":2220,"children":2221},{},[2222,2231],{"type":45,"tag":358,"props":2223,"children":2224},{},[2225],{"type":45,"tag":75,"props":2226,"children":2228},{"className":2227},[],[2229],{"type":50,"value":2230},"observability",{"type":50,"value":2232}," — CloudWatch dashboards, alarms, and logging for ML infrastructure",{"type":45,"tag":64,"props":2234,"children":2235},{},[2236,2245],{"type":45,"tag":358,"props":2237,"children":2238},{},[2239],{"type":45,"tag":75,"props":2240,"children":2242},{"className":2241},[],[2243],{"type":50,"value":2244},"cost-check",{"type":50,"value":2246}," — Detailed cost analysis, Savings Plans recommendations, and Spot vs On-Demand comparison",{"type":45,"tag":64,"props":2248,"children":2249},{},[2250,2259],{"type":45,"tag":358,"props":2251,"children":2252},{},[2253],{"type":45,"tag":75,"props":2254,"children":2256},{"className":2255},[],[2257],{"type":50,"value":2258},"ec2",{"type":50,"value":2260}," — Instance type selection for self-managed training clusters or custom inference servers",{"type":45,"tag":53,"props":2262,"children":2264},{"id":2263},"output-format",[2265],{"type":50,"value":2266},"Output Format",{"type":45,"tag":46,"props":2268,"children":2269},{},[2270],{"type":50,"value":2271},"When recommending an MLOps architecture, include:",{"type":45,"tag":148,"props":2273,"children":2274},{},[2275,2296],{"type":45,"tag":152,"props":2276,"children":2277},{},[2278],{"type":45,"tag":156,"props":2279,"children":2280},{},[2281,2286,2291],{"type":45,"tag":160,"props":2282,"children":2283},{},[2284],{"type":50,"value":2285},"Component",{"type":45,"tag":160,"props":2287,"children":2288},{},[2289],{"type":50,"value":2290},"Choice",{"type":45,"tag":160,"props":2292,"children":2293},{},[2294],{"type":50,"value":2295},"Rationale",{"type":45,"tag":176,"props":2297,"children":2298},{},[2299,2317,2335,2353,2371,2389,2407,2425],{"type":45,"tag":156,"props":2300,"children":2301},{},[2302,2307,2312],{"type":45,"tag":183,"props":2303,"children":2304},{},[2305],{"type":50,"value":2306},"Platform",{"type":45,"tag":183,"props":2308,"children":2309},{},[2310],{"type":50,"value":2311},"SageMaker Pipelines + MLflow",{"type":45,"tag":183,"props":2313,"children":2314},{},[2315],{"type":50,"value":2316},"CI\u002FCD for ML with experiment tracking",{"type":45,"tag":156,"props":2318,"children":2319},{},[2320,2325,2330],{"type":45,"tag":183,"props":2321,"children":2322},{},[2323],{"type":50,"value":2324},"Training Instance",{"type":45,"tag":183,"props":2326,"children":2327},{},[2328],{"type":50,"value":2329},"ml.trn1.32xlarge (Spot)",{"type":45,"tag":183,"props":2331,"children":2332},{},[2333],{"type":50,"value":2334},"Trainium for 50% savings; Spot for additional 60-90%",{"type":45,"tag":156,"props":2336,"children":2337},{},[2338,2343,2348],{"type":45,"tag":183,"props":2339,"children":2340},{},[2341],{"type":50,"value":2342},"Inference Instance",{"type":45,"tag":183,"props":2344,"children":2345},{},[2346],{"type":50,"value":2347},"ml.inf2.xlarge",{"type":45,"tag":183,"props":2349,"children":2350},{},[2351],{"type":50,"value":2352},"Inferentia2 for cost-effective LLM serving",{"type":45,"tag":156,"props":2354,"children":2355},{},[2356,2361,2366],{"type":45,"tag":183,"props":2357,"children":2358},{},[2359],{"type":50,"value":2360},"Inference Pattern",{"type":45,"tag":183,"props":2362,"children":2363},{},[2364],{"type":50,"value":2365},"Real-time endpoint with auto-scaling",{"type":45,"tag":183,"props":2367,"children":2368},{},[2369],{"type":50,"value":2370},"Consistent traffic with latency SLA",{"type":45,"tag":156,"props":2372,"children":2373},{},[2374,2379,2384],{"type":45,"tag":183,"props":2375,"children":2376},{},[2377],{"type":50,"value":2378},"Experiment Tracking",{"type":45,"tag":183,"props":2380,"children":2381},{},[2382],{"type":50,"value":2383},"Managed MLflow on SageMaker",{"type":45,"tag":183,"props":2385,"children":2386},{},[2387],{"type":50,"value":2388},"Zero-infra setup, auto-sync with Model Registry",{"type":45,"tag":156,"props":2390,"children":2391},{},[2392,2397,2402],{"type":45,"tag":183,"props":2393,"children":2394},{},[2395],{"type":50,"value":2396},"Monitoring",{"type":45,"tag":183,"props":2398,"children":2399},{},[2400],{"type":50,"value":2401},"Model Monitor (data quality + model quality)",{"type":45,"tag":183,"props":2403,"children":2404},{},[2405],{"type":50,"value":2406},"Detect drift before business impact",{"type":45,"tag":156,"props":2408,"children":2409},{},[2410,2415,2420],{"type":45,"tag":183,"props":2411,"children":2412},{},[2413],{"type":50,"value":2414},"CI\u002FCD",{"type":45,"tag":183,"props":2416,"children":2417},{},[2418],{"type":50,"value":2419},"CodePipeline triggering SageMaker Pipeline",{"type":45,"tag":183,"props":2421,"children":2422},{},[2423],{"type":50,"value":2424},"Automated training on code merge",{"type":45,"tag":156,"props":2426,"children":2427},{},[2428,2432,2437],{"type":45,"tag":183,"props":2429,"children":2430},{},[2431],{"type":50,"value":1840},{"type":45,"tag":183,"props":2433,"children":2434},{},[2435],{"type":50,"value":2436},"Spot training + Savings Plan on inference",{"type":45,"tag":183,"props":2438,"children":2439},{},[2440],{"type":50,"value":2441},"Minimize both training and serving costs",{"type":45,"tag":46,"props":2443,"children":2444},{},[2445,2447,2452],{"type":50,"value":2446},"Include estimated monthly cost range using the ",{"type":45,"tag":75,"props":2448,"children":2450},{"className":2449},[],[2451],{"type":50,"value":2244},{"type":50,"value":2453}," skill.",{"items":2455,"total":2550},[2456,2470,2485,2496,2508,2521,2535],{"slug":2457,"name":2457,"fn":2458,"description":2459,"org":2460,"tags":2461,"stars":28,"repoUrl":29,"updatedAt":2469},"agentcore","design Amazon Bedrock AgentCore architectures","Deep-dive into Amazon Bedrock AgentCore platform design, service selection, deployment, and production operations. This skill should be used when the user asks to \"design an AgentCore architecture\", \"deploy agents on AgentCore\", \"configure AgentCore Runtime\", \"set up AgentCore Memory\", \"use AgentCore Gateway\", \"configure AgentCore Identity\", \"set up AgentCore Policy\", \"plan agent observability\", \"evaluate agent quality\", \"move agent PoC to production\", or mentions AgentCore, AgentCore Runtime, AgentCore Memory, AgentCore Gateway, AgentCore Identity, AgentCore Policy, AgentCore Evaluations, AgentCore Code Interpreter, AgentCore Browser, A2A protocol, or multi-agent orchestration on AWS.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2462,2465,2468],{"name":2463,"slug":2464,"type":16},"Agents","agents",{"name":2466,"slug":2467,"type":16},"Architecture","architecture",{"name":26,"slug":27,"type":16},"2026-07-12T08:40:11.108951",{"slug":2471,"name":2471,"fn":2472,"description":2473,"org":2474,"tags":2475,"stars":28,"repoUrl":29,"updatedAt":2484},"aidlc-lite","develop AI applications on AWS","Lightweight AI development lifecycle for building on AWS. A simplified take on the AI-DLC philosophy — think together, then build fast. Acts as a design partner that understands intent, proposes alternatives with trade-offs, and ships working code without the ceremony of full requirements\u002Fdesign\u002Fspec documents. Use when a founder says \"build X on AWS\", \"add Y to my stack\", \"scaffold an API\", or \"write the CDK for Z\".",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2476,2477,2480,2481],{"name":2463,"slug":2464,"type":16},{"name":2478,"slug":2479,"type":16},"AI Infrastructure","ai-infrastructure",{"name":26,"slug":27,"type":16},{"name":2482,"slug":2483,"type":16},"Engineering","engineering","2026-07-12T08:40:40.204103",{"slug":2486,"name":2486,"fn":2487,"description":2488,"org":2489,"tags":2490,"stars":28,"repoUrl":29,"updatedAt":2495},"architect-for-startups","advise on AWS architecture for startups","AWS architecture advisor tailored specifically for startups. Alters AWS architecture recommendations based on startup stage (pre-revenue through Series B+), team size, runway, and credits. ALWAYS use when asked about building on AWS, choosing services, planning infrastructure, managing costs with credits, or preparing architecture for fundraising.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2491,2492,2493],{"name":2466,"slug":2467,"type":16},{"name":26,"slug":27,"type":16},{"name":1732,"slug":2494,"type":16},"strategy","2026-07-12T08:41:33.557354",{"slug":2497,"name":2497,"fn":2498,"description":2499,"org":2500,"tags":2501,"stars":28,"repoUrl":29,"updatedAt":2507},"aws-architect","design and review AWS architectures","Design and review AWS architectures following Well-Architected Framework principles. Use when planning new infrastructure, reviewing existing architectures, evaluating trade-offs between AWS services, or when asked about AWS best practices.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2502,2503,2504],{"name":2466,"slug":2467,"type":16},{"name":26,"slug":27,"type":16},{"name":2505,"slug":2506,"type":16},"Infrastructure","infrastructure","2026-07-12T08:40:57.630086",{"slug":2509,"name":2509,"fn":2510,"description":2511,"org":2512,"tags":2513,"stars":28,"repoUrl":29,"updatedAt":2520},"aws-compare","compare AWS architecture options","Compare 2-3 AWS architecture options side-by-side across cost, complexity, performance, security, and operational burden. Use when evaluating trade-offs between approaches or when the user is deciding between options.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2514,2515,2516,2517],{"name":2466,"slug":2467,"type":16},{"name":26,"slug":27,"type":16},{"name":1840,"slug":1837,"type":16},{"name":2518,"slug":2519,"type":16},"Security","security","2026-07-12T08:40:23.960287",{"slug":2522,"name":2522,"fn":2523,"description":2524,"org":2525,"tags":2526,"stars":28,"repoUrl":29,"updatedAt":2534},"aws-debug","debug AWS infrastructure and deployment failures","Debug AWS infrastructure issues, deployment failures, and runtime errors. Use when troubleshooting CloudFormation stack failures, Lambda errors, ECS task failures, permission issues, networking problems, or any AWS service misbehavior.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2527,2528,2531,2532],{"name":26,"slug":27,"type":16},{"name":2529,"slug":2530,"type":16},"Debugging","debugging",{"name":21,"slug":22,"type":16},{"name":2533,"slug":2230,"type":16},"Observability","2026-07-12T08:40:16.767171",{"slug":2536,"name":2536,"fn":2537,"description":2538,"org":2539,"tags":2540,"stars":28,"repoUrl":29,"updatedAt":2549},"aws-diagram","generate AWS architecture diagrams","Generate AWS architecture diagrams in Mermaid or ASCII from a description, existing IaC, or conversation context. Use when the user wants to visualize an architecture.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2541,2542,2543,2546],{"name":2466,"slug":2467,"type":16},{"name":26,"slug":27,"type":16},{"name":2544,"slug":2545,"type":16},"Diagrams","diagrams",{"name":2547,"slug":2548,"type":16},"Visualization","visualization","2026-07-12T08:40:43.26341",42,{"items":2552,"total":2723},[2553,2568,2588,2598,2611,2624,2634,2644,2663,2678,2693,2708],{"slug":2554,"name":2554,"fn":2555,"description":2556,"org":2557,"tags":2558,"stars":2565,"repoUrl":2566,"updatedAt":2567},"agentcore-investigation","investigate Bedrock AgentCore runtime sessions","Investigate Bedrock AgentCore runtime sessions via CloudWatch Logs Insights — resolve session\u002Ftrace IDs, query OTEL spans, filter noise, build timelines. Use when debugging AgentCore agent sessions, tracing tool calls, or analyzing latency.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2559,2560,2561,2564],{"name":26,"slug":27,"type":16},{"name":2529,"slug":2530,"type":16},{"name":2562,"slug":2563,"type":16},"Logs","logs",{"name":2533,"slug":2230,"type":16},9427,"https:\u002F\u002Fgithub.com\u002Fawslabs\u002Fmcp","2026-07-12T08:37:22.601527",{"slug":2569,"name":2570,"fn":2571,"description":2572,"org":2573,"tags":2574,"stars":2565,"repoUrl":2566,"updatedAt":2587},"amazon-aurora-dsql","amazon aurora dsql","build applications with Aurora DSQL","Build with Aurora DSQL — manage schemas, execute queries, handle migrations, diagnose query plans, load data, and develop applications with a serverless, distributed SQL database. Covers IAM auth, multi-tenant patterns, MySQL-to-DSQL and PostgreSQL-to-DSQL schema conversion, FK replacement code generation, OCC retry patterns, ORM migration (Django\u002FHibernate\u002FRails), DDL operations, query plan explainability, SQL compatibility validation, and bulk data loading. Triggers on phrases like: DSQL, Aurora DSQL, create DSQL table, DSQL schema, migrate to DSQL, distributed SQL database, serverless PostgreSQL-compatible database, DSQL query plan, DSQL EXPLAIN ANALYZE, why is my DSQL query slow, DSQL foreign key, DSQL OCC retry, DSQL multi-region, load into DSQL, load CSV into DSQL, bulk load DSQL, aurora-dsql-loader.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2575,2578,2579,2582,2584],{"name":2576,"slug":2577,"type":16},"Aurora","aurora",{"name":26,"slug":27,"type":16},{"name":2580,"slug":2581,"type":16},"Database","database",{"name":629,"slug":2583,"type":16},"serverless",{"name":2585,"slug":2586,"type":16},"SQL","sql","2026-07-12T08:36:45.053393",{"slug":2589,"name":2590,"fn":2571,"description":2572,"org":2591,"tags":2592,"stars":2565,"repoUrl":2566,"updatedAt":2597},"aurora-dsql","aurora dsql",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2593,2594,2595,2596],{"name":26,"slug":27,"type":16},{"name":2580,"slug":2581,"type":16},{"name":629,"slug":2583,"type":16},{"name":2585,"slug":2586,"type":16},"2026-07-12T08:36:42.694299",{"slug":2599,"name":2600,"fn":2571,"description":2572,"org":2601,"tags":2602,"stars":2565,"repoUrl":2566,"updatedAt":2610},"aws-dsql","aws dsql",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2603,2604,2605,2608,2609],{"name":26,"slug":27,"type":16},{"name":2580,"slug":2581,"type":16},{"name":2606,"slug":2607,"type":16},"Migration","migration",{"name":629,"slug":2583,"type":16},{"name":2585,"slug":2586,"type":16},"2026-07-12T08:36:38.584057",{"slug":2612,"name":2613,"fn":2571,"description":2572,"org":2614,"tags":2615,"stars":2565,"repoUrl":2566,"updatedAt":2623},"distributed-postgres","distributed postgres",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2616,2617,2618,2621,2622],{"name":26,"slug":27,"type":16},{"name":2580,"slug":2581,"type":16},{"name":2619,"slug":2620,"type":16},"PostgreSQL","postgresql",{"name":629,"slug":2583,"type":16},{"name":2585,"slug":2586,"type":16},"2026-07-12T08:36:46.530743",{"slug":2625,"name":2626,"fn":2571,"description":2572,"org":2627,"tags":2628,"stars":2565,"repoUrl":2566,"updatedAt":2633},"distributed-sql","distributed sql",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2629,2630,2631,2632],{"name":26,"slug":27,"type":16},{"name":2580,"slug":2581,"type":16},{"name":629,"slug":2583,"type":16},{"name":2585,"slug":2586,"type":16},"2026-07-12T08:36:48.104182",{"slug":2635,"name":2635,"fn":2571,"description":2572,"org":2636,"tags":2637,"stars":2565,"repoUrl":2566,"updatedAt":2643},"dsql",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2638,2639,2640,2641,2642],{"name":26,"slug":27,"type":16},{"name":2580,"slug":2581,"type":16},{"name":2606,"slug":2607,"type":16},{"name":629,"slug":2583,"type":16},{"name":2585,"slug":2586,"type":16},"2026-07-12T08:36:36.374512",{"slug":2645,"name":2645,"fn":2646,"description":2647,"org":2648,"tags":2649,"stars":2660,"repoUrl":2661,"updatedAt":2662},"cost-efficiency-analyzer","analyze cost efficiency and expenses","Analyzes cost structure, cost efficiency, and expense management from P&L data. Use when the user asks about costs, expenses, COGS, operating expenses, cost ratios, cost control, spending efficiency, margin compression from cost side, or wants to understand where money is going. Also use for \"are we spending too much\", \"cost breakdown\", \"expense analysis\", or \"how efficient are our operations\". NOT for revenue or top-line analysis.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2650,2653,2656,2657],{"name":2651,"slug":2652,"type":16},"Accounting","accounting",{"name":2654,"slug":2655,"type":16},"Analytics","analytics",{"name":1840,"slug":1837,"type":16},{"name":2658,"slug":2659,"type":16},"Finance","finance",3176,"https:\u002F\u002Fgithub.com\u002Fawslabs\u002Fagentcore-samples","2026-07-12T08:40:03.29555",{"slug":2664,"name":2664,"fn":2665,"description":2666,"org":2667,"tags":2668,"stars":2660,"repoUrl":2661,"updatedAt":2677},"executive-financial-briefing","generate executive financial briefings","Generates a concise executive-level financial briefing or summary suitable for a CEO, CFO, or board presentation. Use when the user asks for a summary, briefing, executive summary, board update, financial overview, financial health check, or \"how is the business doing\". Covers the full P&L picture in one page. Also use for \"give me the highlights\", \"what do I need to know\", or \"quick financial update\".",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2669,2670,2671,2674],{"name":26,"slug":27,"type":16},{"name":2658,"slug":2659,"type":16},{"name":2672,"slug":2673,"type":16},"Management","management",{"name":2675,"slug":2676,"type":16},"Reporting","reporting","2026-07-12T08:40:02.066471",{"slug":2679,"name":2679,"fn":2680,"description":2681,"org":2682,"tags":2683,"stars":2660,"repoUrl":2661,"updatedAt":2692},"multi-quarter-trend-analysis","analyze multi-quarter financial trends","Analyzes financial trends across multiple quarters by comparing P&L metrics over time. Use when the user wants to see trends, patterns, trajectories, or directional movement across 3 or more quarters. Also use for \"how are we trending\", \"show me the trend\", \"track performance over time\", \"quarter over quarter comparison across all quarters\", or any multi-period longitudinal analysis.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2684,2685,2686,2689],{"name":2654,"slug":2655,"type":16},{"name":2658,"slug":2659,"type":16},{"name":2687,"slug":2688,"type":16},"Financial Statements","financial-statements",{"name":2690,"slug":2691,"type":16},"Variance Analysis","variance-analysis","2026-07-12T08:40:00.79141",{"slug":2694,"name":2694,"fn":2695,"description":2696,"org":2697,"tags":2698,"stars":2660,"repoUrl":2661,"updatedAt":2707},"pdf","process and manipulate PDF documents","Use this skill whenever the user wants to do anything with PDF files. This includes reading or extracting text\u002Ftables from PDFs, combining or merging multiple PDFs into one, splitting PDFs apart, rotating pages, adding watermarks, creating new PDFs, filling PDF forms, encrypting\u002Fdecrypting PDFs, extracting images, and OCR on scanned PDFs to make them searchable. If the user mentions a .pdf file or asks to produce one, use this skill.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2699,2702,2705],{"name":2700,"slug":2701,"type":16},"Automation","automation",{"name":2703,"slug":2704,"type":16},"Documents","documents",{"name":2706,"slug":2694,"type":16},"PDF","2026-07-12T08:41:44.135656",{"slug":2709,"name":2709,"fn":2710,"description":2711,"org":2712,"tags":2713,"stars":2660,"repoUrl":2661,"updatedAt":2722},"quarterly-kpi-calculator","calculate quarterly financial KPIs","Calculates quarterly financial KPIs from P&L data. P&L figures can be provided directly by the user or fetched from the financial data MCP server. Use when the user wants KPI calculations such as Gross Margin %, EBITDA Margin %, Operating Expense Ratio, or Revenue Growth % QoQ. Also use for quarterly performance review, P&L analysis, or interpreting financial ratios against benchmarks.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[2714,2715,2718,2719],{"name":2651,"slug":2652,"type":16},{"name":2716,"slug":2717,"type":16},"Data Analysis","data-analysis",{"name":2658,"slug":2659,"type":16},{"name":2720,"slug":2721,"type":16},"KPI","kpi","2026-07-12T08:39:59.54971",150]