Forem: Jess Lulka

February 2026 DigitalOcean Tutorials: Claude 4.6 and AI Agents

Jess Lulka — Thu, 05 Mar 2026 17:00:00 +0000

Whether you’ve found yourself exploring Anthropic’s latest Claude Opus 4.6 release or following along with the OpenClaw frenzy, DigitalOcean has tutorials and guides to help you get the most out of the latest AI advancements.

These 10 tutorials from last month cover AI agent development, RAG troubleshooting, CUDA performance tuning, and OpenClaw on DigitalOcean. Bookmark them for later or keep them open among your 50 browser tabs to come back to.

What’s New With Claude Opus 4.6

Claude Opus 4.6’s agentic coding model feels less like a coding assistant and more like a collaborative engineer. Developers now have a massive 1M-token context window, which lets the model reason across entire codebases, docs, and long workflows without constantly re-prompting. This means faster refactors, more reliable debugging, and the ability to make iterative UI or architecture changes with just a few guided prompts. Long context plus agentic planning dramatically reduces the time between the idea and working implementation, especially when the model is directly integrated into your cloud stack.

Self-Learning AI Agents: A High-Level Overview

Self-learning agents follow a fundamental loop: observe, act, get feedback, and improve. For developers, these systems aren’t just prompt-driven. They’re built around policies, reward signals, and evolving memory. We make the concept approachable by showing how you can prototype simple versions with standard Python ML tooling. This tutorial can help you determine whether your agent needs to adapt to changing environments or user behavior. You’ll also get a look at how reinforcement-style learning and persistent memory become essential design choices.

CUDA Guide: Workflow for Performance Tuning

Frustrated by the guesswork involved in GPU optimization? We’ve got a step-by-step guide for you. Learn how to profile first, identify the real bottleneck—memory, compute, or occupancy—and then apply targeted optimizations rather than random tweaks. For developers working with AI or HPC workloads, the biggest win is understanding that most performance gains come from a structured workflow, not exotic kernel tricks. You’ll learn that knowing how to measure, optimize, and re-measure is the only reliable path to predictable CUDA speedups.

A Simple Guide to Building AI Agents Correctly

This tutorial is a production blueprint for agentic systems. It covers why naive agent loops fail—runaway costs, hallucinated tool calls, and silent errors—and provides a modular architecture that includes an orchestrator, structured tools, memory, guardrails, and full observability. The most valuable takeaway for real deployments is the “start with the least autonomy” principle: Use deterministic workflows first, and add agent behavior only where it’s truly needed. You want to treat agents like serious software systems with testing, logging, and permissions, not clever prompt chains to get them running correctly.

Why Your RAG Is Not Working Effectively

If your RAG app feels inaccurate or inconsistent, this tutorial helps you diagnose the real cause; it’s usually retrieval quality, chunking strategy, or missing evaluation rather than the model itself. You’ll walk through concrete fixes like better indexing, query rewriting, and relevance filtering so your system actually returns grounded answers. The key takeaway is that RAG performance is mostly a data-pipeline and retrieval-engineering problem, not an LLM problem.

How to Connect Google to OpenClaw

If you’re looking for how to connect AI assistants to real-time data, this guide shows how to wire external data sources into your agent workflow so it can act on real user content instead of static prompts. The practical win is learning how authentication, connectors, and permissions shape what your agent can safely do in production. You'll learn how to deploy OpenClaw on a DigitalOcean Droplet and connect it to Google services like Gmail, Calendar, and Drive using OAuth authentication.

So You Installed OpenClaw on a DigitalOcean Droplet. Now What?

We’ve penned plenty of resources on how to get started with OpenClaw on DigitalOcean (how to run it and how we built a security-hardened Droplet). This follow-up focuses on moving from a working prototype to a more capable, extensible system. You learn how to layer in new tools, expand automation flows, and structure your project so it scales beyond a demo. The key takeaway is architectural: design your agent environment so new capabilities are plug-and-play rather than requiring rewrites.

Effective Context Engineering to Build Better AI Agents

The prompts you feed your AI agent matter just as much as the model behind it. Instead of cramming everything into a single prompt, this article shows you how to structure memory, retrieval, tool outputs, and task state so the model always sees the right information at the right time. You’ll see how using enough context is your real control surface for agent reliability, latency, and cost. Good context engineering often beats switching to a larger model.

Sliding Window Attention: Efficient Long-Context Modeling

Sliding window attention makes long-context transformers far more practical by limiting how many tokens each position can “see.” Instead of every token attending to every other token (which gets expensive fast), the model focuses on a fixed local window—cutting compute costs from quadratic to linear growth. You’ll get a breakdown of how this works, how modern variants improve positional awareness, and why it’s especially useful for long documents, extended chat histories, or agent memory systems. Smarter attention design—not just bigger models—is what makes long-context AI scalable.

How to Run Open-Weight Nemotron 3 Models on a GPU Droplet

Jess Lulka — Tue, 03 Mar 2026 18:41:16 +0000

This article was original written by Andrew Dugan (Senior AI Technical Content Creator II)

NVIDIA has announced the newest additions to their Nemotron family of models, Nemotron 3. There are three separate models in the Nemotron 3 family that are being released, including Nano, Super, and Ultra, which have 30, 49, and 253 billion parameters respectively with up to 1M tokens in context length. Nano was released in December of 2025, and Super and Ultra are scheduled to be released later in 2026. They are being released on NVIDIA’s open model license, making them available for commercial use and modification and giving you ownership and complete control over generated outputs. Both the weights and training data are open and available on Hugging Face. This tutorial will discuss these models and how to deploy the currently available Nano on a DigitalOcean GPU Droplet.

Key Takeaways

NVIDIA has announced Nemotron 3, a new addition to their Nemotron model lineup. Nemotron 3 consists of three new models, Nano (30B), Super (49B), and Ultra (253B).
As of January, 2026, the smallest model, Nano, is the only one currently available for use. Super and Ultra are scheduled for release later in 2026.
All of the models are open-weight, allowing for open access for commercial use and modification. The models’ architectures employ novel efficiency improvements to increase model throughput.

Model Overviews

The Nemotron 3 models use a Mixture of Experts hybrid Mamba-Transformer architecture that is meant to increase the token generation speed, otherwise known as throughput. This means that the models have fewer layers of self-attention and instead use Mamba-2 (state space model) layers and Mixture-of-Experts (MoE) layers that are computationally less expensive and faster, especially for longer input sequences. This allows the Nemotron 3 models to process longer texts faster while using less memory and resources. Some attention layers are included where needed to keep accuracy as high as possible.

NVIDIA describes each of the three models as optimized for different platforms. Nano provides cost efficiency for targeted agentic tasks without sacrificing accuracy. Super offers high accuracy for multi-agentic reasoning. Ultra maximizes reasoning accuracy.

Nano is the smallest of the three and is comparable to Qwen3-30B and GPT-OSS-20B in performance. It is the only of the three that is available as of January 2026.

Nano can be used for both reasoning and non-reasoning tasks with an option to turn off the reasoning capabilities through a flag in the chat template. Responses will be less accurate if reasoning is disabled in the configuration.

Nano is a hybrid Mixture-of-Experts (MoE) architecture that consists of 23 Mamba-2 and MoE layers and six attention layers, with each MoE layer including 128 experts plus one shared expert. Five experts are activated per token, making 3.5 billion of the 30 billion total parameters active.

Super and Ultra both use LatentMoE and Multi-Token Prediction (MTP) layers that further increase text generation speed. MTP is the ability to predict multiple tokens at once in a single forward pass instead of only predicting a single token. LatentMoE is a novel approach to assigning experts that compresses the input data size each expert needs to process in order to reduce the amount of computation for each token. They use these efficiency savings to increase the number of experts that can be used for each token.

In NVIDIA’s white paperon the release, they describe Super as optimized for workloads like IT ticket automation where collaborative agents handle large-volume workloads. Ultra is the option to use when accuracy and reasoning performance are paramount.

Step 1 - Creating a GPU Droplet

To deploy the Nemotron 3 Nano on a DigitalOcean GPU Droplet, first, sign in to your DigitalOcean account and create a GPU Droplet.

Choose AI/ML-Ready as your image and select an NVIDIA H100. Add or select an SSH Key, and create the DigitalOcean Droplet.

Step 2 - Connecting to Your GPU Droplet

Once the DigitalOcean Droplet is created, you SSH(Secure Shell) into your server instance. Go to your command line and enter the following command, replacing the highlighted your_server_ip placeholder value with the Public IPv4 of your instance. You can find the IP in the Connection Details section of your GPU Instance Dashboard.

ssh root@your_server_ip

You may get a message that reads:

OutputThe authenticity of host 'your_server_ip (your_server_ip)' can't be established.....Are you sure you want to continue connecting (yes/no/[fingerprint])?

If you do, you can type yes and press ENTER.

Step 3 — Installing Python and vLLM

Next, verify you are still in the Linux instance, and install Python.

sudo apt install python3 python3-pip

It may notify you that additional space will be used and ask if you want to continue. If it does, type Y and press ENTER.

If you receive a “Daemons using outdated libraries” message asking which services to restart, you can press ENTER.

After Python has finished installing, install vLLM.

pip install vllm

This package might take a little while to install. After it is finished installing, download the custom parser from Hugging Face.

wget https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16/resolve/main/nano_v3_reasoning_parser.py

The custom parser interprets Nemotron-3 Nano v3’s reasoning and tool-calling markup so vLLM can correctly serve responses and route tool calls.

Step 4 - Serving the Nemotron Model

Specify exactly which model you want to serve using the model’s ID from Hugging Face.

vllm serve --model nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16 \
 --max-num-seqs 8 \
  --tensor-parallel-size 1 \
  --max-model-len 262144 \
  --port 8000 \
  --trust-remote-code \
  --reasoning-parser-plugin nano_v3_reasoning_parser.py \
  --reasoning-parser nano_v3

The max-num-seqs is the maximum number of outputs that can be processed concurrently. You can have up to eight single-output requests processed at a single time in this example.

The tensor-parallel-size is the number of GPUs you are spreading the model across via tensor parallelism. One is equal to a single GPU. The max-model-len is the maximum total tokens per request. trust-remote-code is necessary for Nemotron’s custom chat template and parsing logic.

Finally, the reasoning-parser-plugin and reasoning-parser parameters load and select the custom reasoning parser.

Once the model is loaded and served on your instance with vLLM, you can make inference calls to the endpoint using Python locally or from another server. Create a Python file called example_vllm_request.py and run the following code. Replace your_server_ip with the IP address of your GPU Droplet.

import requests

url = "http://your_server_ip:8000/v1/completions"
data = {
    "model": "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16",
    "messages": [{"role": "user", "content": "What is the capital of France?"}],
    "max_tokens": 1000
}

response = requests.post(url, json=data)
message = response.json()['choices'][0]['message']['content']
print(message)

You will see output similar to the following:

Output
The capital of France is **Paris**.

If you print out the entire response.json() object, you can view the reasoning tokens. If you would like to run it with reasoning disabled, you can add a chat_template_kwargs parameter to the data object above.

data = {
    "model": "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16",
    "messages": [{"role": "user", "content": "What is the capital of France?"}],
    "max_tokens": 1000,
    "chat_template_kwargs": {"enable_thinking": False},
}

FAQ

What are the hardware requirements and GPU memory needed to run Nemotron 3 Nano locally?

Nemotron 3 Nano can run on GPUs with at least 60 GB of VRAM in BF16 precision, such as an A100 80 GB or H100. A quantized version may allow it to run on GPUs with less memory.

Can I fine-tune Nemotron 3 Nano on my own data, and what are the licensing implications?

Yes, Nemotron 3 models are released under NVIDIA’s open model license, which permits commercial use, modification, and fine-tuning. You retain complete ownership of any outputs generated and can fine-tune the model on custom datasets for your specific use cases.

What is the difference between the Mixture-of-Experts (MoE) architecture and traditional transformer models in terms of inference cost?

The MoE architecture only activates five out of 128 experts per token (3.5B of 30B parameters), making inference much more efficient than traditional dense models.

Has NVIDIA released other LLMs in the past?

Yes, NVIDIA has released a large number of open models and datasets, including other Nemotron model versions, Megatron, ASR models, and more.

Conclusion

The Nemotron 3 family is a comparatively effective and efficient open model with fast inference and accurate results. The smallest version, Nano, is currently available as of January 2026, and the other two larger versions will become available in coming months.

In this tutorial, you deployed Nemotron 3 Nano on a DigitalOcean GPU Droplet. Next, you can build a workflow that uses it for any data sensitive applications that require a high degree of privacy and control.

Technical Deep Dive: How we Created a Security-hardened 1-Click Deploy OpenClaw

Jess Lulka — Tue, 24 Feb 2026 22:11:29 +0000

This article was originally written by Freddie Rice (Staff Product Security Engineer)

OpenClaw, an open source AI assistant (recently renamed from Moltbot, and earlier Clawdbot), has exploded in popularity over the last few days, and at DigitalOcean we immediately wondered “how can we enable more people to try this new technology safely and easily?” We noticed that there was a lot of interest by folks looking to use this software, but also that there was concern around the security of the open source software, especially when connecting it directly to users’ own machines. We dug in to find a way to deliver this software to our customers as fast as possible, as easily as possible and as safe as possible.

At DigitalOcean, our 1-Click Deploy OpenClaw (formerly 1-Click Deploy Moltbot) through our Marketplace enables us to package the latest and greatest software configured for our Droplet® server, and make it easily available to customers. Creating our 1-Click Deploy OpenClaw was the natural next step in getting this to our customers.

Toying around with OpenClaw on a local machine is fun, but it could severely impact the ability to deploy and use the software for longer term use and may not meet the safe environment that you need. Some of the benefits to deploying on DigitalOcean include:

Always available – the service is available to customers via the web
Easy to connect to it – Droplets have a static ip address
Vertical scalability – scale up CPUs, memory, and disk storage with higher workloads
Cognitive overload – start with basic configs, tweak the ones that matter to you

We made a lot of changes as we built the 1-Click Deploy OpenClaw, but the main elements we focused on were

How do we communicate with the service safely?
How do we keep the agentic code isolated from the rest of the system?
How do we prevent attacks from the wider internet?

All of that while providing a straightforward deployment UX to our customers! Let’s dig in…

Delivering an Image with Safe Defaults

Our priority in creating a 1-Click Deploy OpenClaw on our Droplet was twofold: First, speed, as we wanted to get something out quickly to our users. Second was providing a solution that provided additional security benefits. These are the actions we took to meet those goals:

Keeping deployments consistent (DevOps)

We saw that there are multiple ways to deploy the software – we chose the most consistent path, which was picking a stable release from the Git repository on GitHub, pulling it and building from there.

Why not pull the latest and greatest from main? Changes are happening at a rapid pace, which is awesome for feature development but can come at the expense of stability. Depending on the minute we build our 1-click image, we could get a working version or a broken version.

So we make sure that we can deliver the latest stable version.

TLS (Keep communications safe and auditable)

Once we had a Packer image that we could iterate on, we applied our security best practices for the 1-clicks to set up TLS. This is a crucial step to make sure that our customers can communicate with the bot in a safe way that doesn’t allow eavesdropping.

Our best practices consist of using Caddy as a reverse proxy with a TLS certificate issued by LetsEncrypt. Caddy ensures that the service is deployed externally is the service we want to publish and provides a safe channel with which to serve it. Furthermore, Caddy outputs logs to a location that can be audited after the fact, allowing the end user to see how their service is actually being used.

A new UX improvement we added to this image is seamless TLS configuration with LetsEncrypt via IP addresses without requiring a domain name! While OpenClaw spins up, Caddy is requesting a new certificate on your behalf, no configuration required.

Authz (Gateway Key + Pairing)

How do we know that the requests are coming from you? We have a OpenClaw gateway key in place to make sure that the user who is supposed to use the platform is the correct one.

Next, we leaned into a feature that OpenClaw provides called “Paring” – this exists to make sure that the devices that are going to communicate with the main server are the trusted ones.

Sandboxing (keep safe from Agents)

Part of the configuration is an Anthropic / OpenAI / Model key – these are sensitive pieces of material that are required in order to allow the software to function! So how do we let agents that can run arbitrary code on the machine, not read and abuse these tokens?

Furthermore, how do we stop the agents from potentially destroying the machine itself?

Luckily, there is a configuration available that puts the agent deployments into their own containers. If an agent blows up, it will destroy its own ephemeral docker container, but the host filesystem will still be safe from incorrect agentic modifications.

Safe Defaults

These boxes are taking the best configurations that we implement for all of our 1-clicks, including but not limited to:

Fail2ban – Make sure that the background noise of the internet doesn’t cause disruptions to your droplet. It does this by monitoring the logs of failed requests to the system and dynamically updating firewall rules to block known bad patterns on the internet.

Unattended upgrades – We want to make sure that your Droplet is always up to date. We have Ubuntu configured with unattended upgrades that periodically will check for vulnerable packages and automatically patch them.

Deployment Constraints and Upcoming Features

To ensure a stable and repeatable installation, we utilize Packer for our image provisioning; however, during testing, we found that smaller Droplet configurations consistently encountered out-of-memory errors during the snapshot creation process. While this currently necessitates a minimum $24/month Droplet size to match the snapshot’s disk and memory requirements, we chose to prioritize getting this tool into your hands today rather than delaying for further optimization. We are already iterating on the image to reduce its footprint and support lower-cost tiers, and in the spirit of transparency, we have made our Packer scripts public so you can audit the provisioning process and gain confidence in the one-click experience. We are also working to quickly add support for all DigitalOcean Gradient AI models, including OpenAI, add auto provisioning of Gradient AI API Key and injecting for the user, and more updates as OpenClaw evolves over time.

After deploy (make it yours!)

1-Click Deploy OpenClaw is a great launch point, but OpenClaw is infinitely customizable once up and running in the Droplet. Choose which messaging platforms are the best fit for your workflows, and get chatting.

Get started with the 1-Click Deploy OpenClaw

Get started with the 1-Click Deploy OpenClaw by visiting the Marketplace, and follow this tutorial for step by step instructions on how to get started.

4 AI Models (That aren’t Opus 4.6) on Our Minds This Week

Jess Lulka — Mon, 23 Feb 2026 19:59:44 +0000

So many models, so little time. Today, we’re bringing our attention to some super cool releases from Qwen, MiniCPM-o, ACE-Step, and GLM-OCR. So what can these models do?

Qwen3-Coder-Next: An open-weight model built for coding agents and local development that speeds up deployments just as well as more compute-hungry models. By activating just 3B parameters out of 80B total, the model can rival models that require far more compute, making large-scale deployment markedly more economical. The model is also trained for durable agent behavior, including long-horizon reasoning, sophisticated tool use, and recovery from failed executions, and, with a 256k context window plus flexible scaffold support, is designed to integrate smoothly into a wide range of existing CLI and IDE workflows.
MiniCPM-o 4.5: A game-changer for vision performance. The most advanced release in the MiniCPM-o line, packaging a 9B-parameter end-to-end architecture derived from SigLip2, Whisper-medium, CosyVoice2, and Qwen3-8B while adding full-duplex multimodal streaming. The model delivers leading vision performance that rivals or surpasses much larger proprietary systems, supports unified instruction and reasoning modes, and enables natural bilingual real-time speech with expressive voices, cloning, and role play. A major addition is simultaneous video/audio input with concurrent text and speech output, allowing the system to see, listen, talk, and even act proactively in live scenarios. It further strengthens OCR and document understanding, handles high-resolution images and high-FPS video efficiently, supports 30+ languages, and is easy to deploy across local and production environments through broad tooling, quantization options, and ready-to-run inference frameworks.
ACE-Step 1.5: An open-source and legally compliant music foundation model built to deliver commercial-grade generation on everyday hardware, enabling creators to safely use outputs in professional projects. Trained on a large, legally compliant mix of licensed, royalty-free, and synthetic data, the system can produce complete songs in seconds while running locally on GPUs with under 4GB of VRAM. Its hybrid design uses a language model as an intelligent planner that turns prompts into detailed musical blueprints—covering structure, lyrics, and metadata—which are realized by a diffusion transformer, aligned through intrinsic reinforcement learning rather than external reward models. Beyond raw synthesis, ACE-Step v1.5 supports fine stylistic control, multilingual prompting, and flexible editing workflows such as covers, repainting, and vocal-to-instrumental conversion.
GLM-OCR: A multimodal system for advanced document understanding built on the GLM-V encoder–decoder framework. To boost learning efficiency, accuracy, and transferability, it incorporates Multi-Token Prediction (MTP) objectives together with a stable, end-to-end reinforcement learning strategy across tasks. The architecture combines a CogViT visual backbone pre-trained on large image-text corpora, a streamlined cross-modal bridge that aggressively downsamples tokens for efficiency, and a GLM 0.5B language decoder for text generation. Paired with a two-stage workflow, layout parsing followed by parallel recognition using PP-DocLayout-V3, the model achieves reliable, high-fidelity OCR results across a wide spectrum of complex document structures.

They may not have the marketing dazzle of Anthropic’s flagship model, but these four have an incredible amount of potential to help clear some vexing development issues. What models are you keeping an eye on? Add them in the comments.

How to Lower Your AI Costs When Scaling Your Business

Jess Lulka — Fri, 20 Feb 2026 20:31:09 +0000

As AI adoption grows, technological maintenance isn’t the only component you need to keep up with; your budget also requires a watchful eye. Especially when inference workloads can scale data—and costs—quickly. Your AI inference bill comes down to three things: the hardware you use, the scale you need, and how fast it generates output.

If you’re curious how you can lower LLM inference spending, here are three tips to reduce your overall AI costs as you scale:

1. Diversify your hardware

Hardware is a major reason AI has historically been expensive: the only processing units available to run these workloads are GPUs, and demand exceeded supply (driving up costs). This is true for consumer-grade GPUs, where it's not uncommon to see prices two or three times above MSRP, and data center GPU scarcity is even worse.

For a long time, NVIDIA held a large market share with its physical hardware and compute unified device architecture (CUDA)-only frameworks. AMD has since introduced open-source ROCm and made it easier for teams to expand the hardware types they can use for their AI workloads, increasing GPU supply and reducing vendor lock-in.

2. Configuration (Model + KV cache) and quantization

When running LLM inference, pay attention to GPU capacity and speed, as they affect overall performance. You need a minimum amount of memory to even load and run a model. Additional capacity beyond that allows you to have a bigger KV cache, which is critical to high-throughput performance; the KV cache stores the history of each conversation for each user that the GPU is currently serving. Without it, your token generation becomes slower, and inference speed slows down. With it, you can serve more users at once and keep token generation steady.

Beyond using a KV cache and optimizing your model, consider quantization. This practice reduces precision, so less memory (or VRAM) is required to store tokens. A 5000-token conversation, for example, will take several gigabytes of GPU memory (VRAM) to store. These gigabytes contain a massive amount of numbers that the GPU reuses during inference. Each of these numbers requires 2 bytes of memory when using the default 16-bit precision. With 8-bit precision, you only need 1 byte to store the same number of tokens and reduce the overall memory requirements by half. Though your hardware must support 8-bit models for this to work effectively.

3. Optimize your parallelism setup

AI production workloads are massive and require gigabytes (or even terabytes) to just load models. Even if you could load a single model onto a GPU that supports 8-bit models, there’s no guarantee that you would be able to successfully have enough memory to run your model and associated activations (calculations the LLM does during inference) on just one GPU. This is where tensor parallelism and data parallelism improve performance.

When you spread your LLM models across multiple GPUs, you reduce the overall calculations (and memory) required per GPU, leaving plenty of room for activations and the KV cache. If you choose to apply this technique, consider the technical overhead of GPU data coordination and synchronization.

If you’re curious to see a practical application of these techniques, you can read our full Character.ai case study for a technical deep dive. With these workflows in place, the company reduced its inference costs by 50% while continuing to support an app with 10s of millions of users.

How to Run OpenClaw with DigitalOcean

Jess Lulka — Tue, 10 Feb 2026 18:45:07 +0000

OpenClaw (formerly known as Moltbot and Clawdbot) is an open-source, self-hosted personal AI assistant that can run directly on your computer. It can execute a variety of tasks, such as managing your calendar, browsing the web, organizing files, managing your email, and running terminal commands. It supports any Large Language Model (LLM), and you can communicate with it through standard chat apps that you already use like WhatsApp, iMessage, Telegram, Discord, or Slack.

While it is technically possible to run OpenClaw on your local machine, security concerns arise when giving an AI agent open access to your computer with all of your personal data on it. A better approach is to deploy it on a separate machine specifically for OpenClaw or to deploy it on a cloud server.

There are 3 ways to deploy OpenClaw with DigitalOcean. You can either deploy yourself on a DigitalOcean Droplet, deploy with a pre-built 1-Click Application in the Droplet Marketplace, or use the DigitalOcean App Platform. Each of these options will have different security and maintenance considerations, so choose an option based on your app’s needs.

When to choose each deployment option

Bare DigitalOcean Droplet: Deploy directly on a DigitalOcean Droplet only if you require full control over server configuration and are comfortable managing security hardening manually.
1-Click Application: A 1-Click Application is best for solo developers who want improved security benefits with a fast, self-contained deployment with maximal control, and minimal abstraction. This requires minimal decisions and setup. It is a great option for fast experimentation, but it is not as scalable as the App Platform option.
App Platform: The App Platform is best for teams with a production-level deployment that requires long-term operational maturity. For example, if you need to scale quickly (horizontal auto-scaling), need operational consistency with automatic restarts, zero-downtime deploys, or sleep mode requirements for cost optimization.

Both the 1-Click Application and the App Platform deployment options will be covered in this tutorial below. If you prefer to manually deploy OpenClaw on a DigitalOcean Droplet without a 1-Click Application or the App Platform, you can follow the Quickstart Guide.

The DigitalOcean 1-Click and App Platform deployments handle many of the security best practices for you automatically. These security enhancements include:

Authenticated communication: Droplets generate an OpenClaw gateway token, so communication with your OpenClaw is authenticated, essentially protecting your instance from unauthorized users.
Hardened firewall rules: Droplets harden your server with default firewall rules that rate-limit OpenClaw ports to prevent inappropriate traffic from interfering with your OpenClaw use and to help prevent denial-of-service attacks.
Non-root user execution: Droplets run OpenClaw as a non-root user on the server, limiting the attack surface if an inappropriate command is executed by OpenClaw.
Docker container isolation: Droplets run OpenClaw inside Docker containers on your server, setting up an isolated sandbox and further preventing unintended commands from impacting your server.
Private DM pairing: Droplets configure Direct Message (DM) pairing by default, which prevents unauthorized individuals from being able to talk to your OpenClaw.

While deploying this way on a cloud server offers security benefits, OpenClaw is still quite new. Like many new tools, it might have architectural characteristics that have not been designed to work with additional security features yet. Therefore, with added security features, some of OpenClaw’s functionality may not function as perfectly as it was intended. For example, some skills might not work out-of-the-box and can require some additional manual set up.

Key Takeaways

OpenClaw is a powerful, self-hosted AI assistant that can execute tasks like managing calendars, browsing the web, and running terminal commands. It should not be run on your personal machine due to significant security risks associated with giving an AI agent high-level system access.
Deploying OpenClaw on a DigitalOcean 1-Click Application or on the App Platform provides a safer environment through security features like authenticated communication, hardened firewall rules, non-root user execution, Docker container isolation, and private Direct Message (DM) pairing.
OpenClaw is model-agnostic and supports various LLMs via Application Programming Interface (API) keys or local deployment, making it flexible for different use cases and preferences.

In this tutorial, you will first deploy an OpenClaw instance onto DigitalOcean’s 1-Click Deploy OpenClaw. Then you will deploy an instance on the App Platform. If you only need to be able to deploy on the App Platform, skip ahead to that section below.

1-Click Application

Step 1 — Creating an OpenClaw Droplet

First, sign in to your DigitalOcean account and create a Droplet. On the Create Droplets page in the DigitalOcean Control Panel, under Region, select the region closest to you. Under Choose an Image, select the Marketplace tab.

In the search bar, type OpenClaw and select the OpenClaw image from the search results.

Next, choose a Droplet plan. The Basic plan with at least 4GB of RAM (such as the s-2vcpu-4gb size) is recommended for running OpenClaw effectively.

Under Authentication, select SSH Key and add your SSH key if you haven’t already. If you need to create an SSH key, follow the instructions in How to Add SSH Keys to New or Existing Droplets.

Finally, give your Droplet a hostname (such as OpenClaw-server), and click Create Droplet.

Alternatively, you can create an OpenClaw Droplet using the DigitalOcean API. To create a 4GB OpenClaw Droplet in the NYC3 region, use the following curl command. You’ll need to either save your API access token to an environment variable or substitute it into the command:

curl -X POST -H 'Content-Type: application/json' \
     -H 'Authorization: Bearer '$TOKEN'' -d \
    '{"name":"choose_a_name","region":"nyc3","size":"s-2vcpu-4gb","image":"openclaw"}' \
    "https://api.digitalocean.com/v2/droplets"

Once your Droplet is created, it takes a few minutes to fully initialize. After initialization, you can SSH into your Droplet using the IPv4 address shown in your DigitalOcean dashboard:

ssh root@your_droplet_ip

Replace your_droplet_ip with your Droplet’s actual IP address.

Once logged in, the OpenClaw installation will be ready to configure. The DigitalOcean 1-Click Deploy OpenClaw includes OpenClaw version 2026.1.24-1 pre-installed with all necessary dependencies.

You will see a welcome message from OpenClaw. Under the Control UI & Gateway Access section, you will see a Dashboard URL. Note the Dashboard URL value. You will use it later to access the GUI in your browser.

You will see a welcome message from OpenClaw. Under the Control UI & Gateway Access section, you will see a Dashboard URL. Note the Dashboard URL value. You will use it later to access the GUI in your browser.

Within the terminal, choose Anthropic as your AI Provider. If you have access to Gradient AI, you can select that option. OpenAI models will be available soon. Once you select your provider, provide the respective API/Secret key.

Step 2 — Using OpenClaw

With the 1-Click Application, there are 2 ways to use OpenClaw: you can either use the Graphical User Interface (GUI) through your browser, or you can use the Text User Interface (TUI) through your terminal.

After entering your API key, it may ask if you want to run pairing automation now. This pairing is to give you access to the UI dashboard (GUI). If you would like to use the GUI, you can type yes and enter.

It will then provide you with a url. Open a browser, and in the URL bar, paste the provided URL from OpenClaw. This will open an OpenClaw GUI directly in your browser using the Gateway token to authenticate you for additional security. You will then need to go back to the terminal, type continue, and press enter to continue the automated pairing.

In your browser, click refresh, and you will be directed to the default chat page.

Here you can type a message and send, and OpenClaw will respond. For example, if you ask about what files it can see, it will tell you.

Input
What files can you currently see on my computer?

Output
Here’s a list of the files and directories currently visible in the sandbox workspace:
.
├── AGENTS.md
├── BOOTSTRAP.md
├── HEARTBEAT.md
├── USER.md
└── skills
    ├── 1password
    │   ├── SKILL.md
    │   └── references
...

From the GUI, you can review the bot’s usage, add communication channels, schedule cron jobs, add skills, and manage all aspects of OpenClaw.

To use the TUI, run the following command:

/opt/openclaw-tui.sh

Note: Depending on the version, the script may also be located at /opt/clawdbot-tui.sh.

You’ve now successfully deployed OpenClaw on DigitalOcean and accessed it through a web browser. From here, you can explore additional OpenClaw capabilities, such as browsing the web, managing files, or executing terminal commands on your Droplet.

Step 3 - Installing Skills with the 1-Click Application

OpenClaw comes with over 50 skills automatically loaded in the skill registry. You can install skills in the GUI by navigating to the Skills section in the browser dashboard. For example, to integrate with Google Calendar, search for calendar, and click on Install.

A large number of skills are available to perform a wide range of tasks including managing your files, automating web browsing, monitoring health and smart home technologies, and managing social media communication. Read through What is OpenClaw? for an overview of how OpenClaw works and what OpenClaw’s capabilities are.

App Platform

Step 1 - Creating the OpenClaw App

Deploying through DigitalOcean’s App Platform follows a slightly different process. First, go to the OpenClaw App Platform repo and click on the Deploy to Digital Ocean button.

Add your model access key to the GRADIENT_API_KEY parameter. This will allow you to use your Gradient AI Serverless Inference account for the OpenClaw bot. Finally, click on Create APP. It can take up to 5 minutes to finish building the app.

After it has finished building, go to the Console tab of the app, and confirm it is working by typing in:

openclaw gateway health --url ws://127.0.0.1:18789

You now have a working OpenClaw App. If you would like to connect to it remotely, you will need to install and configure doctl, the official command line interface (CLI) for the DigitalOcean API. You will need to follow the instructions to create an API token, use the API token to grant account access to doctl, then use the doctl apps console command to initiate a console session for the app. This step is not completely necessary because you can just use the Console in your application through the DigitalOcean website.

Step 2 - Connecting OpenClaw to WhatsApp

When you initiate the console session, you will be accessing it as the root user. So first, you need to change to the openclaw user:

su openclaw

Then you need to change directories into the home directory of the openclaw user:

cd

Note: The cd command without arguments changes to the current user’s home directory. Since you’re now the openclaw user, this will navigate to /home/openclaw.

To connect your OpenClaw application to WhatsApp, go to the Console of your OpenClaw application enter the following command:

openclaw channels login --channel whatsapp

Follow the instructions to scan the QR code and connect with your bot through WhatsApp.

Step 3 - Installing Skills with the App Platform Application

To install skills through the App Platform application, from the openclaw user in the console, browse skills with the following command:

openclaw skills

Find a skill that you would like to use and install it with the following command, replacing skill_name with the name of the skill you would like to install:

npx clawhub install <skill_name>

You now have an OpenClaw App Platform application with a WhatsApp connection and skills. You can execute the openclaw command to access the rest of openclaw’s features.

FAQ

Can I use a model other than Claude?

Yes, OpenClaw is designed to be model-agnostic, so it does support models other than Anthropic’s Claude. It allows users to use various Large Language Models (LLMs) via API keys or locally. However, note that using the DigitalOcean 1-Click Deploy OpenClaw as outlined above, most users will only be able to use Anthropic (support for OpenAI coming soon!).

Can I deploy it on other operating systems that are not Linux?

Yes, you can deploy OpenClaw on Windows, macOS, and Linux, and other platforms.

What are the main security concerns?

The main security concerns are its high-level system access, potential for misconfiguration, and its ability to execute arbitrary code that might be harmful to your system. It’s important to be aware of the environment in which it’s deployed and the access it has.

How do I give API Key access to my Agents?

It is possible to selectively give agents more control over the world around you. The default OpenClaw application will keep these keys together in an environment that is available to all agents. This configuration gives you control to inject the keys you want to the agents that should have those powers. On the “Agents” Menu bar, select the Agent you’d like to grant access (or “Defaults” for all), then under Sandbox > Docker > Env, add the selected API Keys that should be used.

How does pricing work with OpenClaw?

OpenClaw is free and open-source to download and use, but you are paying for the LLM tokens. Therefore, the price depends on your usage. You should be careful with this because with scheduled jobs or other functionality, the costs can increase quickly and unexpectedly.

Conclusion

In this tutorial, you deployed OpenClaw on DigitalOcean, creating a secure environment for your personal AI assistant. By running OpenClaw on a cloud server instead of your local machine, you’ve significantly reduced security risks while maintaining the full functionality of this powerful tool.

The DigitalOcean OpenClaw deployment provides critical security features out of the box—including authenticated communication, hardened firewall rules, Docker container isolation, and non-root user execution—that make it safer to experiment with AI agent capabilities. You accessed it through a web browser and can now execute various tasks through your preferred messaging apps. Next, try adding new skills to your OpenClaw instance and customize the app to best suit your agentic needs.

January 2026 DigitalOcean Tutorial Roundup: OpenClaw and LangSmith

Jess Lulka — Thu, 05 Feb 2026 17:00:00 +0000

Regardless of where you are on your AI knowledge journey, the DigitalOcean Community offers hundreds of tutorials you can explore and test in your own development environment. With so much new technical content published each month, we’re sharing regular roundups of the latest (and most interesting) AI and machine learning guides to help you stay current.

The new year kicked off with some hot topics—like OpenClaw—alongside foundational refreshers such as advanced PyTorch. Here’s a look at 10 tutorials published in January 2026 to add to your weekend reading (and coding).

How Moltbot Works Behind the Scenes

Discover what makes the OpenClaw (formerly Moltbot) AI agent so effective and what it actually does under the hood. This overview walks through its architecture and the tools you can connect for personalized workflows and recommendations. You’ll also learn how it integrates with applications, what security risks to watch for, and how to launch it on DigitalOcean Droplets in just a few clicks.

The Practical Guide to Advanced PyTorch

Ready to level up your PyTorch skills? This hands-on guide goes beyond the basics, getting into performance tuning, advanced training patterns, and real-world scaling techniques. You’ll learn how to write cleaner, faster, and more efficient code while avoiding common bottlenecks.

Introduction to Topic Modeling in NLP

Topic modeling helps you make sense of large volumes of text without manually labeling everything. This tutorial walks through the fundamentals of Latent Dirichlet Allocation (LDA) and shows how to uncover hidden themes across documents, tickets, or transcripts. With clear examples and visualizations, you’ll turn unstructured text into actionable insights.

Create and Implement Data-Secure AI Workflows

Security shouldn’t be an afterthought when working with AI and sensitive data. This article explains how to design workflows that protect user information and reduce risk across your entire pipeline. From access controls to safe model usage patterns, you’ll learn how to properly evaluate models and manage LLM workflow data securely.

Multi-Head Attention Explained: Queries, Keys, and Values Made Simple

Transformers power modern AI—but they can feel like a black box. This tutorial breaks down multi-head attention in plain language by explaining queries, keys, and values step by step. You’ll see how multiple heads capture different relationships in data and why that improves performance.

FlashAttention 4: Faster, Memory-Efficient Attention for LLMs

Speed and memory efficiency are critical when running large models at scale. This deep dive into FlashAttention 4 explains how modern attention kernels reduce memory usage and improve inference times on GPUs. Learn what’s changed, when it’s worth adopting, and how it can cut costs while boosting performance.

LangSmith Explained: Debugging and Evaluating LLM Agents

Building agents is fun—debugging them, not so much. This tutorial introduces LangSmith, a toolkit for tracing, testing, and evaluating LLM-powered applications with real observability. You’ll track every call, inspect outputs, and systematically measure quality so you can troubleshoot with confidence instead of guesswork.

How to Write and Implement Agent Skills

As agents become more capable, their frameworks need to stay organized. This guide shows how to create modular “skills” that agents can dynamically load, keeping prompts lean and logic reusable. You’ll structure capabilities into clean, composable units that scale with your project—making agents easier to maintain and extend.

How to Create Data for Fine-Tuning LLMs

Fine-tuning success starts with high-quality data. This tutorial walks through collecting, cleaning, and formatting datasets so your model learns exactly what you want it to. From JSONL structures to balancing human and synthetic examples, it covers the small details that make a big difference in results.

CrewAI: A Practical Guide to Role-Based Agent Orchestration

What if your AI agents worked like a team instead of a single brain? This crash course introduces a role-based framework for organizing multiple agents into roles such as researcher, writer, or manager. You’ll build collaborative workflows where each agent has a defined responsibility—bringing structure, reliability, and scale to multi-agent systems.

DigitalOcean on Dev.to: Practical AI Insights for Builders

Jess Lulka — Mon, 02 Feb 2026 17:25:23 +0000

The gap between “I want to build something with AI” and actually shipping it is still huge—fragmented tooling, constant model churn, tutorials that assume you already know everything. So how do you figure out what n8n project to pursue or why your agent keeps hallucinating? Or even what tools are most useful for your AI projects, no matter the scale?

We're reinvigorating our Dev.to account for putting AI tutorials and technical deep dives in your feed, straight from our technical writing staff. Look forward to guides on topics like running DeepSeek R1 on a GPU Droplet, debugging LangGraph agents, and setting up vLLM for inference—plus video walkthroughs when reading isn't enough.

At DigitalOcean, we're not just a cloud company anymore. With Gradient—our unified AI cloud—we're giving developers GPU infrastructure and an agent platform for running inference at scale. And we've learned a lot along the way that we want to share.

This will include:

Breakdowns of new models, benchmarks, and technical concept foundations.
Tutorials on deploying AI tools, LLM fine-tuning and memory management, and AI agent creation.
Step-by-step articles on model debugging, data control, reinforcement learning, and using DigitalOcean infrastructure.
Videos on vLLM deployment, LangGraph agents, and n8n automation.

How exactly do vibe coding tools work to create applications? Get a rundown of how to use Lovable and n8n to generate a Yuka-style app—and download the prompts to test it out for yourself.

If you want to keep up with our hands-on tutorials, video walkthroughs, and DigitalOcean best practices, stick around; you might even catch a few discussions, contests, or memes in your feed.

Forem: Jess Lulka

February 2026 DigitalOcean Tutorials: Claude 4.6 and AI Agents

How to Run Open-Weight Nemotron 3 Models on a GPU Droplet

Key Takeaways

Model Overviews

Step 1 - Creating a GPU Droplet

Step 2 - Connecting to Your GPU Droplet

Step 3 — Installing Python and vLLM

Step 4 - Serving the Nemotron Model

FAQ

Conclusion

Related Links

Technical Deep Dive: How we Created a Security-hardened 1-Click Deploy OpenClaw

Delivering an Image with Safe Defaults

Keeping deployments consistent (DevOps)

TLS (Keep communications safe and auditable)

Authz (Gateway Key + Pairing)

Sandboxing (keep safe from Agents)

Safe Defaults

Deployment Constraints and Upcoming Features

After deploy (make it yours!)

Get started with the 1-Click Deploy OpenClaw

4 AI Models (That aren’t Opus 4.6) on Our Minds This Week

How to Lower Your AI Costs When Scaling Your Business

1. Diversify your hardware

2. Configuration (Model + KV cache) and quantization

3. Optimize your parallelism setup

How to Run OpenClaw with DigitalOcean

When to choose each deployment option

Key Takeaways

1-Click Application

Step 1 — Creating an OpenClaw Droplet

Step 2 — Using OpenClaw

Step 3 - Installing Skills with the 1-Click Application

App Platform

Step 1 - Creating the OpenClaw App

Step 2 - Connecting OpenClaw to WhatsApp

Step 3 - Installing Skills with the App Platform Application

FAQ

Conclusion

Related Links

January 2026 DigitalOcean Tutorial Roundup: OpenClaw and LangSmith

DigitalOcean on Dev.to: Practical AI Insights for Builders