
Martin Maritsch
· 18 min read
Reason over time-series data with OpenTSLM on Amazon SageMaker JumpStart
Across industries, decision-making starts with understanding what is changing and why. Industrial organizations collect data that informs decisions across their operations. This data helps prevent production stoppages, diagnose vehicle faults, explain drops in data-center performance, and adjust pricing as supply and demand shift. However, interpreting that data still requires specialist time, and collecting more data does not mean teams can act on it. General-purpose language models like Claude or ChatGPT can help analyze data. However, processing long histories across hundreds of operational metrics as text or images can consume large numbers of tokens, which increases cost.
To help organizations act on this data, Aionic Labs is developing temporal foundation models, including OpenTSLM, an open source family of time-series language models (TSLMs). These models interpret operational measurements, from equipment sensor data to supply and demand, alongside context such as maintenance records, market news, and an engineer’s observations. In doing so, TSLMs help systems recognize emerging problems in recent measurements. Experts can then ask follow-up questions to understand what changed and assess how to respond. TimeNet, the shared data infrastructure for time-series data, provides one format and API to find, build, and load the datasets used to train and evaluate these models. Together, they help organizations understand how their systems change and act before problems become costly.
OpenTSLM is now available in Amazon SageMaker JumpStart, so you can deploy the model in your own AWS environment. This post explores how Nexthink and Aionic Labs are bringing this capability to proactive IT assistance, then shows how to deploy OpenTSLM and adapt it to your own data using TimeNet.
Figure 1. Time-series language models combine numerical measurements with text context and questions. Potential applications span physical and digital systems, with adaptation and evaluation for each task.
A customer example: Proactive IT support at Nexthink
Nexthink and Aionic Labs are building toward a digital workplace where employees get help before they need to ask for it. At the center is Spark, Nexthink’s personal IT agent, enhanced with time-series language models that connect device telemetry and context to the problems employees experience. Spark turns that understanding into action: it checks the likely issue, guides the employee through an appropriate fix, and follows up on the result. Proactive assistance becomes part of keeping work moving.
The workflow combines recent device time-series, such as CPU activity, memory use, available disk space, application stability, and connectivity, with timestamped events and device and software context. The TSLM receives the numerical measurements alongside this text context and interprets how the signals change over the observation window.
The TSLM provides Spark with three outputs:
- State summary: Explains the likely issue and the supporting signal patterns, connecting device behavior with the employee’s experience.
- Recommended action: Specifies checks to confirm the issue and a practical action for Spark to offer the employee.
- Expected outcome: Describes the intended improvement and how Spark checks the result.
Device telemetry and context support investigation of a range of issues, including slow performance under high CPU or memory load, recurring application freezes or crashes, and files that fail to synchronize. Resource usage, application events, storage measurements, and connection activity provide different pieces of evidence. Combined with device configuration and software versions, they give the TSLM a broader basis for explaining the employee’s experience and directing Spark’s next checks.
In the illustrative low-disk example in Figure 2, the TSLM connects declining free space, a rising disk queue, and more frequent application hangs with likely employee symptoms, such as a slow computer or difficulty saving files. Spark checks how much space is left and whether temporary files can be removed using an IT-approved cleanup. If the checks confirm that a cleanup is appropriate, Spark shows the employee what it proposes to remove and asks for confirmation. After the employee confirms, Spark runs the cleanup, checks the space now available, and asks whether the problem has improved. If the issue persists, Spark offers to pass the findings to IT support.
TSLMs understand how systems change and help people act on that understanding. For Spark, this means recognizing emerging IT problems and guiding employees toward a solution. The same approach brings time series intelligence to manufacturing, energy, and connected products, turning measurements and context into explanations and intelligent decisions.
Figure 2. Illustrative proactive support workflow for low disk space at Nexthink. OpenTSLM generates a state summary, a recommended action, and an expected outcome from device history and context. Spark checks the device, runs an IT-approved cleanup after employee confirmation, and follows up on the result.
Solution overview
The architecture in Figure 3 provides a reusable deployment pattern for time-series applications. SageMaker JumpStart supplies the model discovery and deployment path.
SageMaker JumpStart is a machine learning (ML) model hub that accelerates your ML journey. With SageMaker JumpStart, you can evaluate, compare, and deploy pretrained foundation models (FMs), including the newly available OpenTSLM model. As part of the AWS AI offerings, SageMaker JumpStart provides customizable ML solutions which you can deploy to Amazon SageMaker AI inference endpoints within your AWS infrastructure. It complements Amazon Bedrock, which offers serverless API foundation model inference along with features like customizations, knowledge bases, agents, and guardrails.
Key technical benefits of SageMaker AI and SageMaker JumpStart include:
- Pre-built inference containers – AWS Deep Learning Containers with GPU acceleration, so you can serve the model without building your own image.
- Automatic scaling endpoints – Managed infrastructure scales compute resources based on request volume and latency requirements.
- Inference API – SageMaker real-time inference endpoints with standardized API calls, SDK, and AWS Identity and Access Management (IAM) integration.
- Integrated monitoring – Built-in metrics for throughput, latency, and resource utilization with an Amazon CloudWatch integration.
- Enterprise security – Amazon Virtual Private Cloud (VPC) deployment with IAM access control and network isolation options.
The model in SageMaker JumpStart is OpenTSLM-Flamingo. It combines the Gemma 3 4B language model with a time-series encoder and cross-attention layers that let the language model attend to the encoded series. The model has 5.24 billion parameters in total, stored in bfloat16, so its weights take about 10.5 GB of GPU memory.
An application prepares numerical time series and text context, invokes the SageMaker endpoint, and receives the model’s response. The application can present that response to an expert or use it as input to another workflow.
This separation allows the application to control the observation window, select relevant signals, and validate the response before using it. It also makes the model independently adaptable: a new checkpoint can be evaluated against representative cases before the application switches to it.
In addition, we show a tutorial that fine-tunes a pretrained OpenTSLM checkpoint from Hugging Face using ARFBench data loaded through TimeNet. The notebook submits a SageMaker training job that loads ARFBench through TimeNet and fine-tunes the model. Amazon Simple Storage Service (Amazon S3) stores the resulting model artifact, which is then deployed to a separate SageMaker real-time inference endpoint for evaluation.
Figure 3. A reusable architecture for deploying OpenTSLM through SageMaker JumpStart and invoking it from applications that combine time-series data with text context.
Prerequisites
For the deployment walkthrough, use an AWS account with an Amazon SageMaker AI domain and a SageMaker AI execution role. The role must be able to create SageMaker models and endpoints in a supported Region, for example a role with the AmazonSageMakerFullAccess managed policy. The quick setup for single users creates both. The managed policy grants broad permissions to get started. For production, use a policy that grants only the permissions you need, as described in Amazon SageMaker AI identity-based policy examples. OpenTSLM runs on a single GPU with at least 24 GB of memory and bfloat16 support, and we recommend 32 GB of host memory. The default instance type is ml.g6.2xlarge (one NVIDIA L4 GPU with 24 GB of memory, 32 GB of host memory). In SageMaker JumpStart, OpenTSLM also supports ml.g6.4xlarge, ml.g6.8xlarge, ml.g5.2xlarge, ml.g5.4xlarge, ml.g5.8xlarge, ml.g6e.xlarge, and ml.g6e.2xlarge. In the Service Quotas console, check your quota for “ml.g6.2xlarge for endpoint usage”, or for the instance type you choose. You need a quota of at least 1. If it’s lower, request an increase. See the OpenTSLM JumpStart model card for the model access requirements.
For fine-tuning, use JupyterLab in Amazon SageMaker Studio or a local Jupyter environment with AWS credentials configured to run the accompanying notebook, which submits the training job. The notebook uses the SageMaker default S3 bucket and an execution role. Fine-tuning runs on ml.g7e.2xlarge, so also check your quota for “ml.g7e.2xlarge for training job usage”. Training runs on the job’s managed GPU instance. The notebook itself does not need a GPU. Obtain access to the selected Hugging Face checkpoint where required.
Deploy OpenTSLM with SageMaker JumpStart
To deploy OpenTSLM in SageMaker Studio, complete the following steps:
- In SageMaker Studio, choose Models in the navigation pane, then JumpStart models.
- Search for “OpenTSLM” and choose OpenTSLM-Flamingo Gemma 3 4B. The model page shows the model ID, the license, and the request and response format.
Figure 4: The OpenTSLM-Flamingo Gemma 3 4B model page in SageMaker JumpStart
- Choose Deploy.
- On the Deploy model to endpoint form, review the Gemma Terms of Use under License agreement and select the checkbox to accept the end user license agreement (EULA). Keep the default instance type,
ml.g6.2xlarge, or choose another supported instance type. Then choose Deploy.
Figure 5: The deploy model to endpoint form with the default ml.g6.2xlarge instance type and real-time inference
- Wait until the endpoint status is InService. In our tests, this took about 6 minutes. Note the endpoint name, which starts with
jumpstart-dft-. You need it to send requests and to clean up.
Figure 6: The deployed OpenTSLM endpoint with InService status in SageMaker Studio
You can also create the deployment from Python with the SageMaker Python SDK v3. The following example uses ModelBuilder. The model is gated: setting accept_eula=True accepts its license, the Gemma Terms of Use. Review the terms before you deploy. The SDK prints a link to them when it builds the model.
from sagemaker.core.helper.session_helper import get_execution_role
from sagemaker.core.jumpstart.configs import JumpStartConfig
from sagemaker.serve.model_builder import ModelBuilder
from sagemaker.train.configs import Compute
MODEL_ID = "pytorch-reasoning-opentslm-flamingo-gemma3-4b"
INSTANCE_TYPE = "ml.g6.2xlarge" # 1 x NVIDIA L4 (24 GB); ml.g5.2xlarge and ml.g6e.2xlarge also work
ROLE_ARN = get_execution_role() # in SageMaker Studio; elsewhere, set your execution role ARN
builder = ModelBuilder.from_jumpstart_config(
jumpstart_config=JumpStartConfig(model_id=MODEL_ID, accept_eula=True),
compute=Compute(instance_type=INSTANCE_TYPE),
role_arn=ROLE_ARN,
)
builder.build(model_name="opentslm-blog-demo")
endpoint = builder.deploy(endpoint_name="opentslm-blog-demo")
Ask a question about a time series
The endpoint accepts a JSON request with one or more instances. Each instance holds a question, one or more numerical series, and optional context lines. Each series has its values, a name, and a short description of the signal, such as its unit and sampling interval. A series can hold up to 32,768 values. The endpoint scales each series to a mean of 0 and a standard deviation of 1 and passes the original mean and standard deviation to the model as text, so the model receives both the shape and the scale of the signal. Use None for a missing value. The model masks it.
Send the request with the SageMaker Runtime InvokeEndpoint API. Set ENDPOINT_NAME to match your deployment. The calling identity needs the sagemaker:InvokeEndpoint permission. The following synthetic CPU example shows a request.
import json
import boto3
ENDPOINT_NAME = "opentslm-blog-demo"
runtime = boto3.client("sagemaker-runtime")
# One hour of CPU utilization, one sample per minute, with a five-minute spike.
cpu = [21, 20, 22, 19, 21, 20, 23, 21, 20, 19, 22, 21, 20, 21, 19, 22, 20, 21, 23, 20,
21, 19, 20, 22, 21, 20, 19, 21, 78, 85, 82, 80, 79, 22, 20, 21, 19, 20, 22, 21,
20, 21, 23, 19, 20, 21, 22, 20, 19, 21, 20, 22, 21, 20, 19, 21, 22, 20, 21, 20]
request = {
"instances": [{
"question": "Summarize the pattern and suggest what to check.",
"series": [{
"values": cpu, # use None for a missing value
"name": "CPU utilization (%)",
"text": "CPU utilization (%), 1 sample/minute:",
}],
"context": ["The series covers 10:00 to 10:59 on a web server."], # optional
}],
"parameters": {"max_new_tokens": 128},
}
response = runtime.invoke_endpoint(
EndpointName=ENDPOINT_NAME,
ContentType="application/json",
Body=json.dumps(request),
)
print(json.loads(response["Body"].read())["generated_text"][0])
A request can hold up to four instances, each with 1 to 32 series, and the response contains one answer per instance in generated_text. max_new_tokens accepts values from 1 to 512. The model uses greedy decoding, so the same request typically returns the same answer. A real-time invocation must complete within 60 seconds, and the request body can be up to 6 MB. On ml.g6.2xlarge, the model generates about 20 tokens per second. The endpoint processes the instances of a request in sequence, so response time grows with the number of instances and the length of the answers: an answer of 512 tokens takes about 30 seconds. To stay within 60 seconds, send several instances in one request only with short answers, for example with max_new_tokens of 128. The 6 MB limit also bounds how much series data a request can carry. For long-running requests, you can use asynchronous inference.
You can send the same request with the AWS Command Line Interface (AWS CLI). Save the request as JSON, for example with json.dump(request, open("request.json", "w")), then run:
aws sagemaker-runtime invoke-endpoint \
--endpoint-name opentslm-blog-demo \
--content-type application/json \
--body fileb://request.json \
response.json
cat response.json
Choose an input window that preserves relevant events
OpenTSLM-Flamingo compresses the encoded time series into a fixed-size set of representations before the language model uses it. This bounds the representation passed to the language model, but it does not make the complete system unlimited in memory or guarantee that a brief event remains easy to identify in a very long recording.
Long-context research makes this distinction concrete. TS-Haystack evaluates event retrieval across recordings of different lengths and finds that the evaluated TSLM variants often lose accuracy as the history grows, especially when locating event start and end times. These results motivate testing the chosen checkpoint on the windows and questions used by your application.
Choose a window that contains the event and enough surrounding context to interpret it. For long recordings, compare overlapping windows. Preserve sampling resolution for brief events and align related channels in time. Include units, sampling interval, and the observation period in the text context. Validate both normal and abnormal examples at the intended lengths. The endpoint’s accepted payload size and the model’s useful analysis window are separate constraints.
Fine-tune OpenTSLM on ARFBench with SageMaker
Follow the accompanying fine-tuning notebook for the complete example, from preparing ARFBench data with TimeNet to launching a SageMaker training job and deploying the adapted model.
When should you fine-tune?
Start by testing the pretrained OpenTSLM model on representative examples from your application, and assess how well it answers your questions.
- Use the pretrained model when its answers are correct and its explanations match the signals.
- Improve the input when important information is missing, such as measurement units, sampling rate, system context, or the relevant time window.
- Fine-tune the model when it consistently misses patterns specific to your domain or struggles with your task, even with sufficient context. Use representative signals paired with reviewed answers.
TimeNet provides a consistent way to load the data for training and evaluation. After fine-tuning, compare the adapted model with the original on examples that were not used for training.
Prepare fine-tuning data with TimeNet
ARFBench is a public benchmark of multiple-choice questions about anomalies in Datadog’s software-incident telemetry. We use ARFBench because its multiple-choice answers can be scored automatically, which makes the effect of fine-tuning measurable. The same workflow applies to tasks with open-ended answers, such as the summaries and recommended actions in the Nexthink example. TimeNet serves ARFBench as a versioned dataset: each question is stored with its answer options, its correct answer, and the metric signals. The training job loads ARFBench through TimeNet and the model checkpoint from Hugging Face.
Submit a SageMaker training job and deploy the fine-tuned model
A SageMaker training job runs the OpenTSLM training script on a GPU instance. The job fine-tunes the time-series encoder, the perceiver resampler, the cross-attention layers, and the language model’s token embeddings, and keeps the rest of the Gemma 3 language model frozen. The job saves the fine-tuned model to Amazon S3 in the layout of the Hugging Face model repository and writes the test accuracy before and after training to a metrics.json file. If your SageMaker Studio domain has a default MLflow App, the job also logs the training and validation loss and the test accuracy to it, so you can compare runs in the MLflow UI. In our run on one ml.g7e.2xlarge instance, accuracy on 135 held-out ARFBench questions rose from 5.0% to 45.9%. That is well above the 24.5% that random choice reaches on the full benchmark according to the ARFBench paper. Before fine-tuning, the model left most answers empty. Afterwards, it answered every question with one of the given options. ARFBench serves here as an example application: it shows how to adapt the model to a new task and answer format with a public dataset. The result is not a comparison with other models or an official ARFBench leaderboard result.
The following excerpt from the accompanying notebook starts the training job with ModelTrainer. scripts/train.py loads ARFBench, evaluates and fine-tunes the model, and saves it to FINETUNED_PREFIX.
trainer = ModelTrainer(
training_image=TRAINING_IMAGE, # the SageMaker PyTorch 2.9 training image
source_code=SourceCode(
source_dir="scripts", entry_script="train.py", requirements="requirements.txt"
),
compute=Compute(instance_type="ml.g7e.2xlarge", volume_size_in_gb=100),
stopping_condition=StoppingCondition(max_runtime_in_seconds=24 * 60 * 60),
hyperparameters={"base-model": BASE_MODEL, "output": FINETUNED_PREFIX, "epochs": 3},
role=ROLE_ARN,
)
trainer.train()
To deploy the fine-tuned model, create a new real-time endpoint on ml.g6.2xlarge, or another instance type that the JumpStart model supports, with the same container image and environment variables as the JumpStart model, and the inference script that the accompanying notebook provides. Point its model data to the S3 location of the fine-tuned model files. The request format stays the same, so you can send it the requests from the previous section. The accompanying notebook contains the code.
Adapt the workflow to your domain
The same workflow can be adapted to other time-series tasks by pairing signal windows with relevant questions and reviewed answers. Potential examples include interpreting equipment behavior with maintenance context, explaining energy-consumption patterns with operating conditions, and describing activity from wearable measurements. The data, supervision, and evaluation should reflect the domain and the decision the application is intended to support.
Preserve the timing and meaning of the measurements during preparation, and separate training and evaluation data in a way that reflects deployment. For a predictive task, only information available at prediction time belongs in the input. Domain experts should assess whether an answer is grounded in the signals and useful for the intended workflow. For free-text answers, compare them with reviewed reference answers, for example through expert ratings or LLM-as-a-judge, where a language model scores each answer against a rubric.
Clean up
Deployed endpoints continue to incur charges until you delete them. When you finish, delete the endpoint, its endpoint configuration, and its model. If you deployed from SageMaker Studio, run the following commands instead of choosing Delete on the endpoint page, which deletes only the endpoint. The commands look up the configuration and model names from the endpoint name and delete all three. Set ENDPOINT_NAME to the name of your endpoint, for example the default name that starts with jumpstart-dft- for a Studio deployment:
ENDPOINT_NAME=opentslm-blog-demo
CONFIG_NAME=$(aws sagemaker describe-endpoint --endpoint-name "$ENDPOINT_NAME" \
--query EndpointConfigName --output text)
MODEL_NAME=$(aws sagemaker describe-endpoint-config --endpoint-config-name "$CONFIG_NAME" \
--query 'ProductionVariants[0].ModelName' --output text)
aws sagemaker delete-endpoint --endpoint-name "$ENDPOINT_NAME"
aws sagemaker delete-endpoint-config --endpoint-config-name "$CONFIG_NAME"
aws sagemaker delete-model --model-name "$MODEL_NAME"
Repeat these commands with the name of the fine-tuned endpoint. Stop the notebook application and remove tutorial-specific S3 data and artifacts that you do not intend to retain. The training job stops when it completes.
Conclusion
Time-series language models connect numerical measurements with the questions, context, and expertise people use to make decisions. Across manufacturing, energy, wearables, and digital infrastructure, they give people and applications a common way to interpret how systems change. The broader opportunity is to connect operational history with language, making past observations more useful in current decisions.
OpenTSLM is now available in Amazon SageMaker JumpStart, so you can deploy it to a real-time inference endpoint in your own AWS environment through SageMaker Studio or the SageMaker SDK. TimeNet and SageMaker training jobs provide a path to adapt the model to your domain’s signals and questions.
To get started, explore Amazon SageMaker JumpStart, follow the examples in the AWS Samples repository, and consult the OpenTSLM repository and TimeNet documentation. Start with the public ARFBench example, evaluate it on representative cases, then bring the signals, questions, and expertise from your own domain.
About the authors
Martin Maritsch
Martin is a co-founder of Aionic Labs, where he works on bringing time-series language models from research into production. Previously, he was a Senior Generative AI Architect at AWS, helping enterprise customers build and deploy AI solutions. He holds a PhD from ETH Zurich and was a visiting researcher at Stanford University.
Timo Stoffregen
Timo is a founding engineer at Aionic Labs, where he develops time-series AI and the infrastructure for training and deploying models at scale. Before joining Aionic Labs, he worked at Meta Superintelligence Labs. He holds a PhD in computer vision from Monash University.
Moe Haidar
Moe heads the Agentic AI and Engineering group at Nexthink, where he owns AI architecture and strategy. He oversees engineering for Spark, Nexthink’s AI agent for IT support, as well as Nexthink’s broader AI and engineering initiatives.
Yassine Benyahia
Yassine is an AI Engineering Lead at Nexthink, working on Spark, a personal IT agent built for millions of employees. He bridges AI research and production to create agents that resolve IT issues at scale and learn from every interaction.
Nicolas Jourdan
Nicolas is a Senior AI/ML Specialist Solutions Architect at AWS based in Frankfurt, Germany, where he supports customers building AI and machine learning workloads, from early design decisions through to production. His focus areas include model customization, distributed training, and inference. Before joining AWS, he worked as a research scientist and engineering manager in autonomous driving, drones, and manufacturing, and he holds patents in object detection and anomaly detection.
Mohan Gowda Purushothama
Mohan is a Senior Manager for AI & Analytics Specialist Solutions Architecture at AWS, based in Zurich. He leads a team of specialist solutions architects across EMEA who help customers build and scale generative AI and machine learning workloads on AWS.
Evan Kravitz
Evan is a software engineer at Amazon Web Services, working on SageMaker JumpStart. He is interested in the confluence of machine learning with cloud computing. Evan received his undergraduate degree from Cornell University and master’s degree from the University of California, Berkeley.
Matviy Kruglov
Matviy is a Startup Account Manager at AWS, based in Zurich, Switzerland, where he leads AWS’s relationships with a portfolio of AI and deep tech startups. He partners with founders on technical, commercial, and go-to-market strategy, from first prototype to scale, with a focus on frontier AI model builders and university spin-offs from ETH Zurich and EPFL. Previously, he was with the UC Berkeley SkyDeck Fund, investing in deep tech and AI startups.
Original source
This story was published by AWS Machine Learning Blog and written by Martin Maritsch. SyncAI.news shows a preview; the complete article is on the publisher's site.
Read the full story on aws.amazon.com


