The VergeOS SDK Trilogy: A New Era of Infrastructure Automation

In late January and early February 2026, Verge.io released the first versions of three official SDKs for their VergeOS hyperconverged infrastructure platform. Within the span of just two weeks, they shipped:

• goVergeOS (Go SDK) - Released January 30, 2026
• PSVergeOS (PowerShell Module) - Released January 27, 2026
• pyVergeOS (Python SDK) - Released February 1, 2026

This wasn't just a product launch—it was a statement. Verge.io is serious about infrastructure-as-code, automation, and giving engineers the tools they need to manage their environments programmatically.

⚠️ Important - Active Development Status:

These are first releases and all three SDKs are in active development. They have not yet reached 1.0 status and are intended for:

• ✅ Development environments - Testing and experimentation
• ✅ Homelab use - Learning and prototyping
• ✅ Non-production workloads - Proof of concepts
• ❌ NOT for production - APIs will change, features will evolve

Expect breaking changes, evolving APIs, and potential bugs as these SDKs mature. Thoroughly test in non-production environments before considering any production use.

Why This Matters

For years, Verge.io has been known for its powerful VergeOS hyperconverged infrastructure platform, but automation options were limited to direct REST API calls or the web UI. While the Terraform provider (released in August 2024) opened doors for declarative infrastructure management, many teams needed more flexibility for:

• Custom automation workflows that don't fit the Terraform model
• Integration with existing tooling in Go, Python, or PowerShell ecosystems
• Dynamic infrastructure management that responds to runtime conditions
• Scripting and orchestration for complex deployment scenarios

The simultaneous release of three SDKs addresses all these needs at once, meeting teams where they already are in their technology stacks.

The SDK Trilogy: An Overview

� pyVergeOS - The Python SDK

Repository: https://github.com/verge-io/pyVergeOS
License: MIT
Requirements: Python 3.8+, VergeOS 26.0+

The Python SDK is in active development, bringing VergeOS automation to the Python ecosystem with a clean, Pythonic interface. Perfect for:

• Data center automation integrated with existing Python workflows
• DevOps tooling and CI/CD pipelines
• System administration scripts for routine tasks
• Integration with Python-based platforms (Ansible, SaltStack, etc.)

Key Features:

• Type-annotated for IDE autocomplete and type checking
• Context manager support for automatic cleanup
• Pythonic API design following PEP 8 conventions
• Built-in retry logic and error handling
• Async support for concurrent operations
• Comprehensive filtering and querying

Installation:

# Create a virtual environment (required for Python 3.11+)
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install pyVergeOS
pip install pyvergeos

# Or with uv
uv add pyvergeos

Quick Example:

from pyvergeos import VergeClient

# Using context manager
with VergeClient(
    host="192.168.1.100",
    username="admin",
    password="secret",
    verify_ssl=False
) as client:
    # Create a VM
    new_vm = client.vms.create(
        name="test-vm",
        ram=2048,
        cpu_cores=2,
        os_family="linux"
    )
    
    # Power operations
    new_vm.power_on()
    print(f"Created and powered on: {new_vm.name}")

� goVergeOS - The Go SDK

Repository: https://github.com/verge-io/govergeos
License: MIT
Requirements: Go 1.21+, VergeOS 26.0+

The Go SDK is a type-safe, zero-dependency library currently in development that aims to provide complete coverage of the VergeOS API. Built with modern Go practices, it's designed for:

• Production automation tools that need reliability and performance
• Integration with existing Go ecosystems (Terraform providers, Kubernetes operators, etc.)
• Concurrent operations with goroutines and context support
• Custom tooling where compile-time type safety matters

Key Features:

• Complete VM lifecycle management (create, configure, power, clone, snapshot)
• Advanced networking (virtual networks, firewall rules, DHCP, DNS, VPNs)
• NAS & storage management (volumes, CIFS/NFS shares, snapshots)
• Multi-tenancy support for MSPs and enterprises
• Disaster recovery (cloud snapshots, site synchronization)
• Thread-safe concurrent operations
• Interface-based design for easy mocking and testing

Installation:

go get github.com/verge-io/govergeos

Quick Example:

package main

import (
    "context"
    vergeos "github.com/verge-io/govergeos"
)

func main() {
    client, _ := vergeos.NewClient(
        vergeos.WithBaseURL("https://vergeos.example.com"),
        vergeos.WithBasicAuth("admin", "password"),
    )
    
    ctx := context.Background()
    
    // Create a VM
    vm, _ := client.VMs.Create(ctx, &vergeos.VMCreateRequest{
        Name:     "web-server",
        CPUCores: 4,
        RAM:      8192,
        OSFamily: "linux",
    })
    
    // Power it on
    client.VMs.PowerOn(ctx, vm.ID.Int())
}

⚡ PSVergeOS - The PowerShell Module

Repository: https://github.com/verge-io/PSVergeOS
License: MIT
Requirements: PowerShell 7.4+, VergeOS 26.0+

The PowerShell module is under active development, delivering 200+ cmdlets for comprehensive VergeOS management. Ideal for:

• Windows-centric environments and Active Directory integration
• System administrators familiar with PowerShell workflows
• Enterprise automation with existing PowerShell scripts
• Cross-platform management (works on Windows, macOS, Linux)

Key Features:

• 200+ cmdlets following PowerShell naming conventions
• Pipeline support for bulk operations
• Multi-server management capabilities
• Rich object output for easy filtering and formatting
• Tab completion and help documentation
• Cross-platform compatibility with PowerShell 7.4+

Installation:

# From PowerShell Gallery
Install-Module -Name PSVergeOS

# Or manual installation
git clone https://github.com/verge-io/PSVergeOS.git
Import-Module ./PSVergeOS/PSVergeOS.psd1

Examples: The PSVergeOS repository includes comprehensive examples covering connections, VM management, networking, storage, and more: https://github.com/verge-io/PSVergeOS/tree/main/Examples

Quick Example:

# Connect with interactive credentials (for interactive use)
Connect-VergeOS -Server "192.168.1.111" -Credential (Get-Credential) -SkipCertificateCheck

# Or connect with API token (for automation)
# Set token as environment variable
$env:VERGE_TOKEN = "APIKEYHERE"
Connect-VergeOS -Server "192.168.1.111" -Token $env:VERGE_TOKEN -SkipCertificateCheck

# For persistent token (add to your PowerShell profile)
# [System.Environment]::SetEnvironmentVariable('VERGE_TOKEN', 'APIKEYHERE', 'User')

# List all VMs
Get-VergeVM | Format-Table Name, CPUCores, RAM, PowerState

# Create a VM
New-VergeVM -Name "web-server" -CPUCores 4 -RAM 8192 -OSFamily "linux"

# Power operations with pipeline
Get-VergeVM -Name "web-server" | Start-VergeVM

# Bulk operations
Get-VergeVM -Filter "name like 'test-*'" | Stop-VergeVM

# Multiple connections and connection management
$prod = Connect-VergeOS -Server "prod.local" -Token $env:PROD_TOKEN -PassThru
$dev = Connect-VergeOS -Server "dev.local" -Token $env:DEV_TOKEN -PassThru
Get-VergeConnection | Format-Table Server, Username, IsDefault

Choosing the Right SDK

Each SDK has its strengths, and your choice depends on your team's expertise and use case:

The good news? You don't have to choose just one. All three SDKs use the same underlying VergeOS REST API, so you can use different SDKs for different tasks within the same organization.

Development Status Reminder: These are first releases in active development. APIs will change, features will be added or modified, and breaking changes should be expected. Use these SDKs for learning, development, and homelab experimentation—not for production workloads.

What's Coming in This Series

Over the next few weeks, I'll be diving deep into each SDK with hands-on tutorials:

Part 1: Beyond Terraform - Managing Kubernetes Clusters with pyVergeOS (Python SDK)

Focus: Day-2 operations and cluster lifecycle management

• Discovering and managing existing Talos K8s clusters
• Graceful cluster shutdown/startup with proper ordering
• Cluster cloning for staging/dev environments
• Snapshot management for pre-upgrade backups
• Bulk power operations with parallel execution
• Complementing Terraform workflows with Python scripts

Part 2: Building with goVergeOS (Go SDK)

• Setting up a Go development environment
• Implementing cloud-init for automated configuration
• Building production-grade deployment tools
• Error handling and testing strategies
• Concurrent operations with goroutines
• Creating reusable infrastructure libraries

Part 3: Orchestrating with PSVergeOS (PowerShell)

• PowerShell module installation and configuration
• Interactive VM management workflows
• Building reusable automation scripts
• Pipeline-based bulk operations
• Multi-server management scenarios
• Integration with Active Directory and Windows ecosystems

Each post will include:

• ✅ Complete, working code examples
• ✅ Real-world use cases and scenarios
• ✅ Best practices and gotchas
• ✅ Performance considerations
• ✅ Testing and validation approaches

The Bigger Picture

The release of these three SDKs in development represents an exciting evolution of the VergeOS ecosystem. Combined with the existing tools:

• Terraform Provider (August 2024) - Declarative infrastructure-as-code
• Packer Plugin - Automated image building
• Ansible Collection - Configuration management integration
• Prometheus Exporter - Monitoring and observability

VergeOS is building toward a complete automation toolkit that rivals any major cloud provider. Whether you're managing on-premises infrastructure, building a private cloud, or running an MSP, these developing tools provide a foundation for comprehensive automation.

Getting Started Today

All three SDKs are:

• Open source under the MIT license
• In active development with ongoing feature additions
• Well-documented with examples and API references
• Actively maintained by the VergeOS team
• Pre-1.0 status - expect API changes and improvements

You can start exploring right now:

• Go SDK: https://github.com/verge-io/govergeos
• Python SDK: https://github.com/verge-io/pyVergeOS
• PowerShell Module: https://github.com/verge-io/PSVergeOS

What This Means for You

If you're a VergeOS user, this is an exciting time. The barriers to automation are being removed. Whether you're a Go developer, a Python scripter, or a PowerShell admin, you now have developing first-class tools to manage your infrastructure programmatically. As an early adopter, you can help shape these SDKs by providing feedback and contributing to their development.

If you're evaluating hyperconverged infrastructure platforms, the active development of these SDKs shows VergeOS's commitment to automation. Infrastructure-as-code isn't just a buzzword anymore—it's a requirement. While these SDKs are still maturing, they demonstrate VergeOS's understanding of modern infrastructure management needs.

Stay Tuned

Over the coming weeks, I'll be publishing detailed tutorials for each SDK. We'll build real environments, solve real problems, and explore the capabilities of each toolkit. These tutorials will help you get started with the SDKs while they're in development, and I'll update them as the APIs evolve toward 1.0 releases.

Subscribe to get notified when each part of the series is published, or follow along on GitHub where I'll be sharing all the code examples.

The VergeOS SDK trilogy is here. Let's build something amazing.

Have questions about the SDKs? Found a use case I should cover? Drop a comment below or reach out on GitHub!

Resources

• VergeOS Documentation
• VergeOS GitHub Organization
• goVergeOS Repository
• pyVergeOS Repository
• PSVergeOS Repository
• VergeOS Terraform Provider
• VergeOS Packer Plugin