TLDR

Mini-map navigation: Global view of all infrastructure in one glance. Most strategy games have this, enterprise software doesn’t. Reduces cognitive load so you can focus on solving problems instead of hunting for resources.

Information where you need it: Critical data now displays directly on infrastructure elements. No more clicking through menus to find basic information like available GPUs or job requirements.

Burst budget pool: Unspent budget accumulates for big training runs instead of disappearing. Gives management predictable spending while letting developers scale compute without approval workflows. Eliminates use-it-or-lose-it waste.

Coming soon: Network topology visualization for distributed training placement, mega-cluster rollups for 100K+ GPU deployments, and visual GPU differentiation by performance and VRAM capacity.

This update represents a turning point in development. After showcasing Clustercraft (formerly 3D Compute Manager) to operations teams, ML engineers, and infrastructure leaders, we gathered extensive feedback through playtesting sessions. This update addresses the most critical usability gaps: making infrastructure state instantly visible and eliminating information hunting.

The Problem: Information Overload

Playtesting revealed a consistent pattern: new users struggled to understand what resources they had available and where capacity existed. The interface required clicking through panels to see basic information like GPU counts, space availability, and job requirements.

Operations teams need to make quick decisions under pressure. Hunting for information breaks flow and creates cognitive overhead that doesn’t exist when managing physical infrastructure where you can see capacity at a glance.

The Solution: At-a-Glance Resource Labels

Every infrastructure element now displays critical information directly on the 3D representation:

• Jobs show GPU requirements before placement

• Spaces display available capacity in real-time

• Clusters indicate total resources and utilization

• Information updates live as infrastructure changes

Result: Users can now scan the entire infrastructure landscape and identify available capacity in seconds rather than minutes. Decision-making becomes spatial and intuitive rather than abstract and text-based.

The Problem: Navigation at Scale

As deployments grow to dozens of regions across multiple cloud providers, users lost track of their position and struggled to move between infrastructure locations efficiently. Zooming and panning became tedious when managing global deployments.

This mirrors real operations challenges where teams need to quickly shift attention between different regions, providers, or resource types without losing context.

The Solution: Mini-Map Navigation

A persistent mini-map in the bottom corner provides:

• Overview of entire infrastructure deployment across all regions

• One-click navigation to any location

• Real-time updates as infrastructure changes

• Spatial awareness of resource distribution

Result: Operations teams can now manage global deployments with the same ease as single-cluster environments. Navigation time drops from frustrating to instant.

The Problem: Budget Inflexibility

Traditional enterprise GPU budgeting forces organizations into rigid resource allocation. Teams either reserve too much capacity (wasting budget) or too little (creating bottlenecks). There’s no mechanism for flexible burst capacity when workloads spike.

AI Infra Summit conversations revealed this as a major pain point: organizations want baseline reserved capacity plus the ability to burst when needed without complex approval processes.

The Solution: Burst Budget Pool

The system now separates budget into two categories:

• Reserved capacity: Fixed infrastructure committed long-term

• Burst budget: Accumulated unspent funds available for temporary capacity

How it works:

1. Budget gets allocated hourly based on organizational limits

2. Reserved infrastructure consumes predictable baseline costs

3. Unspent budget accumulates into burst pool

4. Teams can access burst capacity instantly when needed

5. CFO patience mechanics encourage efficient utilization

Result: Organizations maintain stable baseline infrastructure while gaining flexibility to handle spikes, experiments, and temporary large-scale training runs. Budget becomes a tool for enabling work rather than restricting it.

The Problem: Network Topology Blindness

Infrastructure provisioning often ignores network topology, leading to jobs that span multiple switches and suffer communication bottlenecks. Operations teams can’t visualize how nodes are connected or understand why certain workload placements perform poorly.

Distributed training performance depends heavily on GPU interconnect quality. Poor placement decisions waste compute time and budget.

The Solution: Network Visualization (In Progress)

Early implementation shows node connectivity within clusters:

• Visual representation of switch hierarchies

• Hop count indication between nodes

• Clear identification of tightly-connected GPU groups

• Foundation for network-aware job placement

Result: When complete, this feature will enable operations teams to place distributed workloads optimally, ensuring GPUs with high communication requirements get provisioned on tightly-connected hardware.

Future Direction: GPU Size Differentiation

Current feedback indicates all GPUs look identical regardless of capability. Users can’t distinguish between A100s with 80GB VRAM and smaller instances with 16GB just by looking at the interface.

Planned solution:

• GPU width represents VRAM capacity

• GPU height represents computational performance (FP16 flops)

• Physical area becomes a meaningful proxy for capability

• Larger GPUs visually command more space, matching their resource value

This creates intuitive capacity planning where you can see at a glance whether infrastructure can handle memory-intensive models or compute-bound workloads.

Lessons from Real User Feedback

Rather than building features we thought were important, we’re now solving problems real operations teams encounter daily:

1. Speed matters: Every click, every navigation action needs to be instant

2. Information hierarchy is critical: Show the most important data first, details on demand

3. Budget flexibility drives adoption: Teams want safety rails, not roadblocks

4. Physical intuition beats abstraction: Spatial representation feels natural to operations teams

These insights are shaping every design decision as we move toward production release.

Strong Compute provides visual GPU infrastructure management across all major cloud providers. Subscribe to https://words.strongcompute.com for weekly product updates and follow our https://www.youtube.com/@strongcompute for video demos of new features.

Try Clustercraft: https://clustercraft.com

Week 9 delivers the complete game experience. All core systems work together, progression is balanced, and the tutorial guides new players through complex infrastructure decisions. The game is ready for serious feedback from operations teams.

• Interactive tutorial system with contextual guidance for new players

• Balanced progression that scales infrastructure with team demand

• Team satisfaction mechanics with frustration modeling and recovery

• Advanced time controls with multi-speed acceleration up to 10x

• Intelligent burst scaling with GPU selection and pricing visibility

• Complete operational scenarios teaching real infrastructure skills

The game now provides consequence-free learning with authentic decision-making pressure. Operations teams can develop resource allocation, cost management, and team communication skills through engaging gameplay rather than expensive production mistakes.

Apply to playtest here: https://calendly.com/ben-sand/playtest

Strong Compute provides visual GPU infrastructure management across all major cloud providers. Subscribe to words.strongcompute.com for weekly product updates and follow our YouTube channel for video demos of new features.

Update 8 focuses on visual improvements and game mechanics refinement as we approach full release. The interface now feels like an actual game rather than a technical demo.

Visual Transformation

• Enhanced lighting engine with realistic shadows and improved textures

• Cyberpunk-inspired region aesthetics replacing abstract representations

• Particle effects for job creation, completion, and runtime activity

• Animated job shaders with wavy effects indicating active processing

Real-Time Health Visualization

• GPU color changes based on thermal state and workload intensity

• Transparent job overlays maintain visibility of underlying hardware status

• Predictive visual indicators for nodes approaching unhealthy states

• Foundation for performance scaling and utilization indicators

Budget and Performance Tracking

• Historical budget charts with 5-second to daily data rollups

• Custom data management preventing save file bloat

• Chart.js integration with custom formatting for game systems

• Expandable framework for compute utilization and expense metrics

Developer Satisfaction Mechanics

• Ring-shaped progress bars showing time until satisfaction drops

• Resource efficiency affects team morale and operational outcomes

• Wasteful over-provisioning creates developer frustration

• Management sentiment influenced by budget optimization

Game Balance and Strategy

• Multi-dimensional optimization across budget, satisfaction, and performance

• Drag-and-drop burst functionality for demand spike management

• Cascading consequences from poor resource allocation decisions

• Multiple viable strategies creating replayability and skill development

The game now delivers a polished interactive experience with cohesive visual feedback, strategic depth, and realistic operational pressure.

Apply to playtest here: https://calendly.com/ben-sand/playtest

Strong Compute provides visual GPU infrastructure management across all major cloud providers. Subscribe to words.strongcompute.com for weekly product updates and follow ourYouTube channel for video demos of new features.

Week 7 unveils the playable game mode that transforms GPU infrastructure management into an engaging operational challenge. As an operations engineer, you'll manage projects, satisfy development teams, and balance resources while maintaining budgets and meeting deadlines.

Game Mode Overview

The game puts you in the role of an operations engineer responsible for managing GPU infrastructure for your organization. You have projects to complete, team members submitting job requests, and limited resources to work with.

Project Management: Each game session revolves around completing projects that require various computational workloads. Projects have specific requirements and deadlines that drive the operational urgency.

Developer Satisfaction: Team members submit jobs with different priorities and requirements. Their satisfaction levels depend on how quickly you can get their work done and how long jobs sit in queues.

Resource Constraints: Unlike sandbox mode, you start with limited infrastructure and budget. Every decision about provisioning resources affects your bottom line and operational capacity.

Time Management: The game includes time scaling controls that let you accelerate gameplay to see long-term consequences of your infrastructure decisions.

Developer Dynamics and Job Management

Real infrastructure operations involve constant interaction with development teams who have varying needs and patience levels.

Team Member Requests: Developers like Panther submit jobs with specific resource requirements - in this case, needing about 2TB of VRAM for their workload.

Satisfaction Metrics: Each developer has a satisfaction percentage that reflects how well you're meeting their needs. Happy developers contribute more effectively to project completion.

Job Types: Different developers submit different types of work - cycle jobs for rapid iteration, interruptible jobs for longer training runs, each with different impacts on project progress.

Queue Psychology: Developers get frustrated when their jobs sit in queues too long. Their satisfaction drops based on wait times relative to expected job duration.

Infrastructure Provisioning and Cost Management

Game mode forces realistic decision-making about infrastructure allocation and cost control.

Strategic Provisioning: You need to provision clusters with enough capacity to handle incoming work without over-spending on unused resources.

Real-Time Costs: Every node you provision costs money continuously. The cost window shows your budget draining as infrastructure runs, creating pressure to optimize resource allocation.

Scaling Decisions: Do you provision one large cluster or multiple smaller ones? Each approach has cost and operational implications that affect your ability to handle diverse workloads.

Budget Balance: Running out of money means you can't provision additional resources, creating operational constraints that mirror real-world budget pressures.

Project Completion and Progression

The game provides clear objectives and progression mechanics that reflect real infrastructure outcomes.

Progress Tracking: Each completed job contributes to overall project completion. Different job types contribute varying amounts - cycle jobs provide small increments while interruptible jobs make larger contributions.

Completion Rewards: Finishing projects provides budget increases and unlocks more challenging scenarios with larger resource requirements.

Difficulty Scaling: Each new project requires more computational resources than the last, simulating organizational growth and increasingly complex AI workloads.

Performance Metrics: The game will eventually model real AI evaluation metrics, making project progress reflect actual machine learning development cycles.

Operational Consequences

Poor infrastructure management has realistic consequences that teach operational best practices.

Developer Frustration: Let jobs sit in queues too long and developer satisfaction plummets. Unhappy developers become less productive and may create additional operational challenges.

Team Dynamics: As satisfaction drops, developers may become "sloppy" and create conflicts that affect overall project progress and team cohesion.

Recovery Strategies: Learning to manage queues, allocate resources effectively, and maintain team satisfaction becomes critical for project success.

Skill Development: Players develop real operational intuition about resource allocation, queue management, and team communication through gameplay consequences.

Game Loop and Mechanics

The core gameplay loop mirrors actual infrastructure operations work.

Request Management: Jobs come in continuously from team members with varying requirements and urgency levels.

Resource Allocation: You must provision appropriate infrastructure, create suitable spaces for different job types, and assign work to optimal hardware.

Monitoring and Optimization: Use the windowing system to monitor multiple jobs simultaneously while managing costs and resource utilization.

Continuous Improvement: Each project completion provides resources and experience for handling larger, more complex scenarios.

Why Game Mode Matters

Traditional infrastructure training involves either expensive mistakes on production systems or abstract tutorials that don't capture operational pressure. Game mode provides consequence-free learning with realistic constraints.

Skill Transfer: The operational skills developed through gameplay - resource allocation, cost management, team dynamics - directly transfer to real infrastructure work.

Risk-Free Learning: Make mistakes and learn from consequences without affecting actual infrastructure or real development teams.

Engagement: Gamification makes learning infrastructure management engaging rather than tedious, encouraging deeper exploration of operational strategies.

Realistic Constraints: Financial limits, team demands, and time pressure create authentic decision-making scenarios that textbooks can't replicate.

What's Next

Game mode development continues with additional mechanics, more sophisticated project types, and enhanced team dynamics. The goal is creating an authentic infrastructure management experience that builds real operational skills.

The foundation is solid - project management, developer satisfaction, resource constraints, and progression mechanics all work together to create engaging operational challenges.

Strong Compute provides visual GPU infrastructure management across all major cloud providers. Subscribe towords.strongcompute.com for weekly product updates and follow ourYouTube channel for video demos of new features.

Week 6 focuses on the game mechanics that will make the 3D Compute Manager feel like real-world infrastructure operations. We're implementing cost simulation and GPU health monitoring that create authentic operational challenges and decision-making scenarios.

Three Platform Modes

Before diving into the updates, it's worth explaining where this is all heading. The 3D Compute Manager will operate in three distinct modes:

Live Mode: Control your actual GPU infrastructure - real servers, real costs, real workloads across AWS, GCP, Azure, and other providers.

Sandbox Mode: Experiment freely with unlimited resources to understand workflows, test configurations, and explore the interface without constraints.

Game Mode: Experience realistic operational challenges with financial constraints, material limits, and team demands that mirror real-world infrastructure management.

Real-Time Cost Simulation

Managing GPU infrastructure without cost visibility leads to budget disasters. The game mode now implements comprehensive cost tracking that forces realistic resource allocation decisions.

Budget Constraints: You start with limited financial resources and must carefully balance infrastructure costs against operational needs.

Live Cost Tracking: Every node, cluster, and region displays real-time operating costs. The cost window shows your current budget alongside all infrastructure expenses.

Financial Decision Making: Unlike sandbox mode where resources are unlimited, game mode requires strategic thinking about which infrastructure to provision and when to scale down.

Operational Reality: These constraints mirror real enterprise challenges where operations teams must balance performance requirements against budget limitations.

Incoming Job Demand Simulation

Real infrastructure operations involve constant pressure from development teams who need compute resources. The game simulates this demand through job submissions from virtual team members.

Team Member Requests: Developers like Violet, Johnny, and Judy submit jobs with specific resource requirements and deadlines.

Queue Management: Jobs appear in a waiting queue until you allocate them to appropriate hardware by dragging them onto clusters or spaces.

Resource Allocation: You must balance competing demands while managing infrastructure costs and maintaining system performance.

Operational Pressure: Just like real operations work, you're juggling multiple requests while optimizing resource utilization and controlling expenses.

GPU Health Monitoring

Static dashboards don't reflect hardware reality. GPUs running intensive workloads behave differently than idle hardware, and the interface now visualizes these differences.

Temperature Visualization: GPUs change color based on their thermal state - green for healthy, warmer colors for nodes under heavy load.

Workload-Aware Monitoring: Nodes running active jobs display elevated temperatures and increased resource utilization, while idle nodes remain cool.

Health Data Simulation: The system tracks memory usage, compute utilization, and thermal characteristics for each GPU, aggregating data up to the cluster level.

Performance Indicators: Visual cues help identify hardware under stress, enabling proactive management before problems occur.

Visual Health Enhancements

We're experimenting with advanced visualization techniques to make GPU health status immediately obvious.

Thermal Indicators: Nodes running hot jobs display warmer colors, creating intuitive visual feedback about hardware stress.

Future Enhancements: Planning particle effects, flame visualization, and alert systems for critical thermal conditions.

Attention Management: Visual effects will draw focus to hardware requiring immediate attention while keeping healthy systems unobtrusive.

Operational Awareness: The goal is instant visual comprehension of infrastructure health without needing to examine individual metrics.

Game Mechanics Integration

These systems work together to create realistic operational scenarios that mirror actual infrastructure management challenges.

Constraint-Based Decisions: Limited budgets force thoughtful resource allocation rather than unlimited scaling.

Demand Management: Incoming job requests create time pressure and competing priorities similar to real operations environments.

Performance Optimization: Health monitoring adds hardware reliability considerations to resource planning decisions.

Skill Development: Players develop real infrastructure management skills through gamified operational challenges.

Building Toward Launch

The game mechanics are rapidly coming together, with core systems now functional and integrated.

System Integration: Cost simulation, job demand, and health monitoring work together to create coherent operational challenges.

User Experience: Drag-and-drop job assignment makes complex resource allocation feel intuitive and immediate.

Realistic Constraints: Financial and hardware limitations mirror real-world operational decisions without overwhelming complexity.

Timeline: Game mode launches within the next couple of weeks, providing a unique way to experience infrastructure management.

Why This Matters

Traditional infrastructure training involves expensive mistakes on production systems or abstract tutorials that don't reflect real operational pressure. Game mode provides consequence-free learning with realistic constraints and decision-making scenarios.

Players develop intuitive understanding of resource allocation, cost management, and performance optimization through engaging gameplay rather than theoretical study.

Strong Compute provides visual GPU infrastructure management across all major cloud providers. Subscribe towords.strongcompute.com for weekly product updates and follow ourYouTube channel for video demos of new features.

Week 5 brings a fundamental shift in how you interact with GPU infrastructure. We've built a custom windowing manager that transforms the 3D Compute Manager from a single-view interface into a comprehensive operational dashboard where you can monitor multiple aspects of your infrastructure simultaneously.

Custom Windowing Manager

Managing enterprise GPU infrastructure means tracking multiple things at once - job status, cluster health, cost metrics, and resource utilization. Traditional interfaces force you to click between different views, losing context each time you switch.

Draggable Information Cards: Every piece of information in the interface - regions, clusters, jobs, nodes - now opens in draggable cards that you can position anywhere on screen.

Pin and Persist: Click the pin button and cards stay exactly where you put them. Open additional information without losing what you're already monitoring.

Multi-Context Monitoring: Pin a job's status card while managing cluster settings. Watch cost metrics while provisioning new resources. Keep health dashboards visible while debugging performance issues.

Real-Time Updates: Pinned cards update live, so you can watch job progress or cost changes while working on other parts of your infrastructure.

Inspired by Complex Strategy Games

The windowing system draws inspiration from games like Banished, where players manage complex systems by having multiple information panels open simultaneously.

Multiple Windows Philosophy: We've moved away from the mobile app paradigm of "one thing at a time" toward desktop-class interfaces that match the complexity of what you're managing.

Large Screen Optimization: When you're managing thousands of GPUs across multiple cloud providers, you need interface density that matches the scale of your responsibilities.

Contextual Awareness: Keep relevant information visible while performing related tasks, reducing cognitive load and improving operational efficiency.

Enhanced Job Management

Improved Creation UI: Job creation now uses a cleaner, more intuitive interface that guides you through the process without overwhelming options.

Status Monitoring: Pin job status cards to track progress in real-time while working on other infrastructure tasks.

Burst Monitoring: When you burst scale a job to additional cloud resources, keep the status card pinned to watch the provisioning and execution process.

Responsive Console Design

Adaptive Layout: The API console automatically repositions itself based on screen size - staying on the right for wide screens, snapping to the bottom for narrower displays.

Real-Time Command Logging: When the console is open, it intercepts and displays every API call generated by your interface interactions.

Hidden vs Visible: The console can be hidden when not needed, then revealed to show the API commands for any actions you've taken.

Future Enhancement: We're considering persistent command logging so you can see API calls even after closing and reopening the console.

Testing at Enterprise Scale

4,000+ GPU Management: We're testing the practical limits of managing individual GPUs through the visual interface, currently running stress tests with over 4,000 nodes.

Performance Boundaries: Understanding where visual management becomes impractical helps us design the right abstractions for massive deployments.

Optimization Requirements: Managing thousands of nodes reveals performance bottlenecks that need addressing before enterprise deployment.

Technical Implementation

Custom Windowing System: Built from scratch using minimal external dependencies - just one lightweight library for drag-and-drop functionality.

Window Behavior: Cards behave like traditional desktop windows - click to focus, drag to move, pin to persist, with proper z-ordering for overlapping panels.

Resize Capability: Cards that display variable content (like graphs) can be resized, while fixed-content cards maintain optimal dimensions.

Memory Efficient: The windowing system adds minimal overhead while providing desktop-class functionality.

Dashboard-First Approach

This update represents a philosophical shift toward treating infrastructure management as an active monitoring and control task rather than a series of discrete operations.

Operational Context: Real infrastructure management requires maintaining awareness of multiple systems simultaneously while making changes to specific components.

Reduced Cognitive Load: Keeping relevant information visible reduces the mental overhead of remembering system state while performing operations.

Professional Interface: The windowing system provides the interface density and flexibility that professional operations teams need.

What's Next

Week 6 will focus on advanced filtering, grouping, and search capabilities for large-scale deployments. When you're managing thousands of nodes, you need sophisticated tools to find, organize, and operate on specific subsets of your infrastructure.

We're also implementing hierarchical views and abstraction layers that let you zoom between individual node management and high-level cluster operations seamlessly.

Strong Compute provides visual GPU infrastructure management across all major cloud providers. Subscribe towords.strongcompute.com for weekly product updates and follow ourYouTube channel for video demos of new features. Try it today: http://cp.strongcompute.ai

Distributed Storage That Just Works

Real GPU clusters need real storage infrastructure. You can't just assume infinite disk space or ignore what happens when nodes fail.

Cluster Storage Aggregation: Each cluster now tracks total storage capacity across all nodes. When you create datasets, they consume real storage space with actual limits. Try to cache more data than your cluster can handle, and the system will stop you - just like real hardware.

Ceph Integration Behind the Scenes: We're simulating a full Ceph distributed storage implementation. The system automatically pools NVMe drives from individual nodes into a resilient storage cluster with configurable erasure coding for redundancy.

Automatic Resilvering: When nodes join or leave a cluster, the storage system automatically rebalances data to maintain redundancy levels. Your jobs keep running during this process, though performance may be impacted - exactly like real distributed storage behavior.

Advanced Job Scheduling: Three Tiers

Most GPU scheduling systems force you to choose between fairness and efficiency. We've built something better with three distinct job types.

Dedicated Jobs: Run until completion, with subsequent jobs queuing behind them. Perfect for production training runs where you need guaranteed, uninterrupted compute time. Works like traditional SLURM clusters.

Time-Cycled Jobs: Jobs automatically pause and resume on a configurable schedule, allowing multiple workloads to share the same hardware fairly. Even large jobs are guaranteed compute time. Powered by our open-source cycling-utils library with atomic, corruption-resistant checkpoints.

Cycle Jobs: Launch in 10-15 seconds and run in 90-second increments for rapid testing. These ultra-high-priority jobs can interrupt lower-priority workloads for immediate testing, then release resources back to the queue.

Automatic Dependency Management

Dataset Auto-Caching: Jobs automatically trigger dataset downloads when scheduled. No manual pre-staging required - the system handles dependencies intelligently.

Container Snapshots: Jobs wait for required container images and datasets before entering the execution queue, preventing resource waste on incomplete jobs.

Storage-Aware Scheduling: The scheduler considers both compute and storage requirements, ensuring jobs only run when all dependencies can be satisfied.

Real-World Performance Alignment

Launch Times: Cycle and interruptible jobs start in 10-15 seconds on real clusters, enabling genuine rapid iteration at cluster scale.

Migration Speed: Cross-cluster job migration takes 5-15 minutes in production, powered by our 60GB/sec inter-cloud data transfer capabilities.

Business Logic Matching: The scheduling algorithms in the 3D Manager now match our production platform exactly. This isn't a demo approximation - it's the same decision-making logic that manages real enterprise GPU workloads.

Building Production Infrastructure

Storage Resilience: Distributed storage with automatic failure handling prevents data loss and maintains performance under various failure scenarios.

Workload Flexibility: Multiple scheduling paradigms let teams choose the right approach for different job types instead of forcing everything into a single queue model.

Development Velocity: Rapid testing capabilities eliminate the traditional bottleneck where infrastructure access limits iteration speed.

What's Next

Next week we're focusing on advanced visualization and management tools for large-scale deployments. When you're managing thousands of nodes, you need sophisticated filtering, grouping, and search capabilities to maintain operational efficiency.

We're also expanding the cost tracking system to provide job-level expense analysis and multi-dimensional cost breakdowns across providers, regions, and workload types.

Strong Compute provides visual GPU infrastructure management across all major cloud providers. Subscribe to words.strongcompute.com for weekly product updates and follow ourYouTube channel for video demos of new features.

Try it today: http://cp.strongcompute.ai

Performance First: Faster Everything

We've been shipping features rapidly over the past few weeks, and need to do some performance rework.

Faster CRUD Operations: Adding and removing cluster elements should be much faster, especially on less powerful devices.

Caching Improvements: We’re using more of your RAM. The result should be much better performance.

Moved to IndexedDB

Previously we’d crash at the scale of entry level foundation labs ~2000 nodes.

New Storage Architecture: We now allow for a much higher limit.

Current Limitations:

• Viewing 2,000 nodes isn’t great for usability. We’re have several research projects underway to look at the best way to visualise massive assets.

• Graphics wise, at extremes of scale there’s some Z-fighting (things appearing on top of things when they should be underneath) that will also be dealth with

Real-Time Cost Tracking

Dynamic GPU assets traditionally makes costs unpredictable. Even with fixed assets resource consumption is a major factor for organization given the cost of the assets.

We’ve previously built sophisticated cost tracking, much of which is shared with users and we also have additional internal tooling.

This is all coming to our 3D view now

Node-Level Costs: Every node now displays its individual operating cost, updating continuously as market rates change.

Hierarchical Aggregation: Costs roll up automatically from nodes to spaces to clusters to regions. You can see the total cost impact of any infrastructure decision immediately.

Dynamic Pricing: The system simulates real-world cost fluctuations, showing how your expenses change as you scale workloads up and down.

Future Integration: While we're using simulated costs for now, this foundation will connect to real provider APIs to show actual spend across your multi-cloud infrastructure. And most importantly, spend over time and how this approaches limits.

Dynamic Node Statistics

Static infrastructure dashboards don't reflect reality. GPU utilization, temperature, and health change constantly based on workload demands.

Workload-Aware Monitoring: Idle nodes show minimal resource usage and stay cool. Busy nodes running intensive workloads display high VRAM usage and elevated temperatures.

Realistic Behavior: This isn't just cosmetic - it mirrors how actual GPU hardware behaves under different load conditions. In our live view it connects to real hardware metrics.

Health Predictions: The foundation is now in place to simulate hardware failure over time. Nodes that run hot consistently will eventually fail, just like in real data centers.

Building Toward Reality

Performance at Scale: The optimizations ensure the interface remains responsive when managing hundreds of clusters across multiple cloud providers.

Cost Visibility: Real-time cost tracking prevents the budget surprises that plague most GPU deployments.

Predictive Maintenance: Dynamic statistics and failure simulation will help teams anticipate hardware issues before they impact production workloads.

What's Next

Next week we’re focusing on storage infrastructure and resiliency. We're implementing NVMe drive simulation for each node to track storage capacity alongside GPU resources. More importantly, we're building resilience capabilities - when nodes fail, datasets and jobs will automatically redistribute and heal themselves across remaining infrastructure.

This moves us closer to simulating real-world distributed storage behavior where data redundancy and automatic recovery are critical for production workloads.

Strong Compute provides visual GPU infrastructure management across all major cloud providers. Subscribe to words.strongcompute.com for weekly product updates and follow our YouTube channel for video demos of new features.

What's New This Week

This week we're rolling out Blueprints, a fundamental shift in how you approach GPU infrastructure planning. Instead of reacting to immediate needs, you can now design your ideal infrastructure layout and let Strong Compute automatically fulfill it.

Blueprints: Intention Meets Reality

The Problem: Most infrastructure gets built reactively. Someone needs compute, provisions it quickly, and you end up with a sprawling mess of unplanned resources across multiple providers with no clear strategy.

The Solution: Blueprints let you design your infrastructure intentionally. Create blueprint regions, clusters, and nodes that represent what you want to exist. The system then automatically finds and provisions resources that match your specifications.

How It Works:

• Design blueprint infrastructure (displayed as blue wireframes above your real resources)

• System automatically discovers and provisions matching resources

• One-to-one mapping between planned and actual infrastructure

• Clear visual separation between intention (top) and reality (bottom)

Visual Infrastructure Planning

Blueprint regions appear as blue wireframe overlays above your actual infrastructure. This spatial separation makes the relationship between planning and execution immediately clear.

When you create a blueprint cluster with specific GPU requirements, the system goes out and finds real hardware that matches those specifications. Each blueprint node corresponds to an actual server running in a data center somewhere.

The visual layout shows you exactly how your intentions map to reality - no spreadsheets, no abstract resource counts, just direct visual correspondence.

Automatic Resource Fulfillment

Blueprint-to-Reality Mapping: Every blueprint element gets a unique ID that tracks through to actual provisioned resources. This means you can see exactly which real compute corresponds to which planned infrastructure.

Automatic Provisioning: When you create blueprints, the system automatically starts finding and provisioning matching resources across our provider network. No manual procurement, no vendor negotiations, no complex deployment scripts.

Manual Override Available: For specialized requirements, you can manually provision resources and embed the blueprint ID to map them back to your planning layer.

Discrepancy Detection

Over/Under Provisioning Visibility: The visual interface makes it immediately obvious when reality doesn't match intention. Too many resources? You'll see extra infrastructure below your blueprints. Not enough? You'll see unfulfilled blueprint elements.

Organized Infrastructure: Blueprints ensure all your real infrastructure exists for a reason. No more mystery compute that someone spun up "temporarily" six months ago and forgot about.

Capacity Planning: See exactly how much additional infrastructure you need to fulfill your complete blueprint design.

Technical Implementation

Unique Blueprint IDs: Every blueprint element generates a tracking ID that follows through to actual resources, enabling automatic mapping and monitoring.

Multi-Provider Discovery: The system searches across AWS, GCP, Azure, Oracle, Lambda Labs, and our partner network to find resources matching your specifications.

Real-Time Sync: Blueprint fulfillment happens continuously - as resources become available, they automatically map to your outstanding blueprint requirements.

User Experience

Plan-First Workflow: Design your ideal infrastructure layout before provisioning anything. See potential costs, resource allocation, and deployment strategy before committing.

Visual Validation: Immediately see whether your actual infrastructure matches your intended design. No more guessing about resource allocation or wondering why you have compute in unexpected places.

Iterative Refinement: Adjust blueprints in real-time and watch the system adapt resource allocation to match your updated plans.

Coming Soon

We're building several major features for Blueprints. Help us prioritize development by voting on which feature you want to see first:

Blueprint Templates: Pre-built infrastructure patterns for common ML workloads, research environments, and production deployments.

Cost Estimation: Real-time cost projections for blueprint designs across different provider combinations.

Automated Optimization: System recommendations for more efficient blueprint designs based on actual usage patterns.

Try Blueprints Now

Blueprint functionality is live in the sandbox environment at cp.strongcompute.ai

Experiment freely: Create complex blueprint designs and see how the system would fulfill them in practice.

Learn the workflow: Understand how intention-driven infrastructure planning changes your approach to resource management.

Test scenarios: Design blueprints for different workload types and see optimal resource allocation strategies.

Why This Matters

Most infrastructure problems stem from poor planning, not technical limitations. When you can visualize your intended infrastructure before building it, you make better decisions about resource allocation, provider selection, and capacity planning.

Blueprints transform infrastructure management from reactive firefighting to proactive design. You decide what you want, then let the system figure out how to build it efficiently.

This is infrastructure management as it should be - intentional, visual, and automated.

Strong Compute provides visual GPU infrastructure management across all major cloud providers. Subscribe towords.strongcompute.com for weekly product updates.

What's New This Week

We've shipped three major improvements to the 3D Compute Manager based on early user feedback and our commitment to making GPU infrastructure management actually intuitive.

Fixed Node Positioning

The Problem: Physical servers don't move when you start new jobs. But our previous visualization moved nodes around to accommodate job layouts, breaking the connection between interface and reality.

The Solution: Nodes now stay in fixed positions representing their actual physical locations. Jobs dynamically reshape themselves across available hardware instead of moving the hardware around.

Why It Matters: You can now see exactly how your workloads map to actual GPUs in actual racks. No more guessing whether that training job is running on your premium hardware or budget instances.

Better Space Visualization

The Update: Spaces now render as transparent "fence" boundaries instead of solid containers.

The Reasoning: Spaces are software abstractions, not physical hardware. The new transparent design makes this distinction immediately clear - you can see the actual nodes and GPUs inside each logical space.

Space Types at a Glance:

• White: Unallocated/hot spare nodes

• Time-cycled: Shared compute with job rotation

• Dedicated: Traditional SLURM-style queuing

• Workstation: Interactive container environments

• Red: Unhealthy nodes (isolated but visible)

Interactive API Console

The Feature: Every action in the 3D interface now shows the corresponding REST API call in real-time.

How It Works:

• Click to create a region → See POST /regions/create with exact parameters

• Drag jobs between spaces → Watch the migration API calls execute

• Type commands directly → Test against sandbox or live data

The Impact: You learn our API by using the interface. No documentation required, no guessing at parameters. Visual actions map one-to-one with programmatic control.

User Experience Improvements

Drag-and-Drop Still Works: Moving jobs between spaces and clusters remains as simple as click-and-drag, but now you see exactly what API calls make it happen.

Real-Time Health Data: Node status updates live in the interface, with corresponding monitoring API endpoints displayed in the console.

Queue Visualization: Jobs waiting for resources now show clear visual indicators of space requirements before execution.

Technical Implementation

• Region, cluster, and space operations fully functional in API console

• One-to-one mapping between visual actions and REST API calls

• Real-time command generation with proper authentication

• Support for both sandbox experimentation and live infrastructure management

Coming Soon

Jobs and Datasets: Full API console support for job management and dataset operations

Multi-Region Blueprints: Visual planning tools for complex multi-cloud deployments

Enhanced Monitoring: Expanded health metrics and performance visualization

Try It Now

The updated 3D Compute Manager is live in sandbox mode at cp.strongcompute.ai.

For existing users: Your sandbox environments have been updated automatically with the new features.

For new users: Create a sandbox account and experience visual GPU infrastructure management with no setup required.

For enterprise teams: Contact ben@strongcompute.com to discuss live platform integration for your infrastructure.

Feedback Welcome

These updates address the most common requests from our early users. We're continuing to iterate rapidly based on real-world usage patterns and operational needs.

What features would make the biggest difference for your GPU infrastructure management? Send feedback directly through the interface or reach out at ben@strongcompute.com

Strong Compute provides visual GPU infrastructure management across AWS, GCP, Azure, Oracle, and more. Subscribe to words.strongcompute.com for weekly product updates.

Today, we're excited to introduce Strong Compute's 3D Compute Manager — a revolutionary visual interface that transforms how operations teams manage GPU compute infrastructure.

Visual Infrastructure Management Matters

Traditional infrastructure management tools force you to think in abstractions. You're managing "instances" and "clusters" without a clear sense of the physical reality beneath and with no clear way to link hardware health with workload performance and cost. These disconnects leads to inefficiencies, miscommunications, and costly mistakes.

Our 3D Compute Manager bridges this gap by providing a spatial, intuitive representation of your actual hardware. Temperatures, throughput, cost, experiment performance are all cross referenced.

When you see a cluster in our interface, you're looking at a visual representation of real physical servers with real GPUs, organized as they exist in the data center.

What Makes the 3D Compute Manager Different

Real-Time Visual Infrastructure

Every element you see represents actual physical resources. Clusters, nodes, GPUs each with real GPUs that you can monitor and manage in real-time. The health data updates live.

Lift and Shift in one click

Moving workloads between clusters used to require complex migrations and significant downtime. With our 3D interface, you simply drag and drop jobs between spaces, clusters, or even regions.

The system handles all the underlying complexity: workload state saving, provisioning, storage clustering, data movement, network configuration. Workloads pick up where they left unaware they’re now on a new provider, even on different GPUs or a different networking stack.

Intelligent Space Management

Resources are organized into logical "spaces" that help compartmentalize different types of workloads:

• Workstation Spaces: Where users spin up containers and interactive environments

• Dedicated Spaces: For bin packed longer term jobs, like a slurm queue.

• Time-Cycled Spaces: Shared compute that rotates between different jobs, great for maximising resources, and allowing for instant feedback on short test runs of new pipelines.

This organization makes it easy to allocate resources appropriately and ensure different workload types don't interfere with each other.

One-Click Burst Scaling

When you have a job that requires more resources than your current infrastructure can provide, traditional solutions involve lengthy procurement processes or complex auto-scaling configurations. Our "burst" feature lets you instantly provision additional resources from our network of cloud providers. These resources exist only as long as needed and automatically disappear when your job completes.

• Burst Workstations - to temporarily access additional interactive compute i.e. a container you can log into, great if you need bigger or extra GPUs than your reserved clusters to get work done.

• Burst Jobs - grab a whole cluster as spot or on demand to take workloads out of your queue or access larger resources than available in your reserved clusters.

Built for ML Teams

ML Engineers get visual confirmation of resource allocation and can easily move training jobs to optimal hardware configurations.

Ops can manage multi-cloud infrastructure through a single, intuitive interface instead of juggling multiple provider dashboards.

Finance can control costs. Finally.

Execs can see what’s going on without commissioning decks and waiting days or weeks, and make decisions immediately.

Most importantly, it helps get everyone working with each other, letting R&D and ops work hand in hand rather than passing blame or building countermeasures to thwart each other’s system controls.

A Fast and Solid Core

Strong Compute is powered by:

• 60GB/sec cloud-to-cloud transit — the world's fastest inter-cloud data movement

• 7.8-second container launch — industry-leading deployment speed

• Multi-provider integration — seamless management across AWS, GCP, Azure, Oracle, Lambda Labs, and more

• Enterprise security — ISO27001, SOC2, HIPAA, and GDPR compliance underway

Current Status and What's Next

The 3D Manager launches today as a sandbox environment where you can experience the interface and understand how it works. We're running live platform data on our own clusters, and we’re ready to integrate with yours.

This is the foundation for infrastructure management that's as intuitive as moving objects in the physical world.

Try it now

The sandbox environment is available now, jump on:

Try the 3D Manager sandbox and experience visual infrastructure control for yourself.

Subscribe to words.strongcompute.com for weekly product updates and our YouTube channel for weekly how-tos and dev diaries.

Strong Compute provides complete command and control for GPU compute, backed by an on-call MLOps and AI development team. Contact us to learn more about how we can transform your infrastructure management.