Before

• On-premises compute hardware limited to 5 NVIDIA GPUs

• Slow job migration and deployment between cloud providers

• Limited visibility into resource utilization

• High operational overhead managing compute resources

After

• On-premises compute hardware limited to 5 NVIDIA GPUs

• Slow job migration and deployment between cloud providers

• Limited visibility into resource utilization

• High operational overhead managing compute resources

• 44 experiments run across 6 separate AI projects - 23 rapid iteration experiments, 21 long-run training experiments

• 6.5 hours total training time on 256 GPUs in 90 cloud machines across 3 different cloud providers - including H100 and A100 instances

Challenge: Complex AI workloads, scarce hardware

LayerJot, a cutting-edge med-tech startup in Belmont, CA, faced a critical challenge common to AI-driven research teams: managing complex, compute-intensive workloads across multiple datasets and models.

LayerJot’s projects span:

• Computer vision for medical equipment catalog processing

• Multi-modal AI models like CLIP and Llama

• Generalist robot policy models for surgical equipment handling

Solution: Scaling from 5 to 256 GPUs with zero dev-ops

Strong Compute deployed an AI engineer on-site with LayerJot for a full week, working shoulder-to-shoulder with their team to optimize infrastructure and accelerate their AI workloads using the Strong Compute Instant Super Computer.

Technical Deep Dive: Datasets and Model Adaptation

Data Ingested

Models Adapted

On-Site Collaboration: Beyond Infrastructure Management

For one intensive week, Strong Compute embedded an AI engineer directly at LayerJot’s Belmont, CA office. Our engineer worked side-by-side with LayerJot’s team, providing:

• Real-time infrastructure optimization

• Hands-on model adaptation support

• Direct troubleshooting of complex AI workload challenges

• Custom infrastructure configuration tailored to LayerJot’s unique research needs

Key Outcomes

• Resolved Dense Encoder code base issues and successfully ran experiments

• Adapted CLIP-style model for Strong Compute checkpointing

• Successfully trained VLA Robotics repo in interactive containers

• Integrated model checkpoints from ingested datasets

• Demonstrated Claude Code’s capability to adapt complex legacy code bases for training on Strong Compute!

Breakthrough Results

Performance Metrics

• Reduced job deployment time from hours to minutes

• 60GB/sec inter-cloud data transfer speed

• 7.8-second container launch times

Operational Impact

• Resolved complex code base integration challenges

• Enabled continuous experiment-based training

• Simplified multi-provider infrastructure management

Quote from the Customer

“Strong Compute transformed how we think about infrastructure. It’s not just a tool; they are a strategic partner in our AI development.” - Soren Harner, CEO, LayerJot

Looking Forward

LayerJot is now positioned to:

• Scale AI research more rapidly

• Reduce infrastructure management overhead

• Accelerate medical technology innovation

Try Strong Compute Today

Strong Compute: Complete Command and Control for GPU Compute

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.

Arcified’s members—Vijay raj Gohil, a ML Engineer at 2K Games, and Aditya Shah, an ML engineer at Google DeepMind. Their final system, nicknamed ARC Evolve, reached an ≈ 80 % full‑solve rate on training puzzles, far out‑performing baseline numbers typically reported for large frontier models.

What is ARC AGI 2?

The ARC (Abstraction & Reasoning Corpus) tasks created by François Chollet test a model’s ability to infer symbolic transformations from tiny demonstration sets. ARC AGI 2 raises the bar with new transformation families and a strict “all‑or‑nothing” scoring rule: a task is counted only if the model reproduces the entire output grid perfectly. The benchmark has become a proving ground for methods that claim progress toward more general reasoning.

The thought behind the Build

In a single paragraph: Vijayraj Gohil and Aditya Shah, together they sketched a strategy they called “small data, big search.” That ethos shaped every design choice that followed.

Strategy

From One‑Shot RL VR to AlphaEvolve‑Style Search

Arcified’s technical recipe fuses two complementary ideas drawn from very recent literature:

• One‑Shot Reinforcement Learning with Verifiable Rewards (RL VR). A paper released in April 2025 showed that, for reasoning‑heavy datasets, fine‑tuning with just one carefully chosen example plus a binary “full‑solve” reward can match or exceed thousand‑sample runs. Arcified used this paradigm to initialize a compact 7‑billion‑parameter language model for ARC AGI 2.

• AlphaEvolve search. Google DeepMind’s AlphaEvolve project demonstrated how an LLM‑guided evolutionary loop could rediscover matrix‑multiplication breakthroughs after decades. Arcified adapted the same idea to iteratively refine chains‑of‑thought for ARC puzzles, letting a high‑precision evaluator provide graded feedback between generations.

By combining the two, the team produced a self‑improving loop: RL VR delivers an initial policy; AlphaEvolve‑style search mutates that policy’s reasoning trace until it converges on a stable program that maps input to output.

How It Works—A Closer Look

1. Task taxonomy and sampling
   ARC AGI 2 examples fall into three geometric regimes:

   • No‑change (input and output are the same size),

   • Contraction (output is smaller), and

   • Expansion (output is larger).
     

2. Arcified built histograms to quantify the prevalence of each regime in the public training set, then repeated the analysis on held‑out evaluation tasks. They discovered that most puzzles clustered in the no‑change and contraction buckets. Using that insight, they curated ten “high‑entropy” samples—balanced across regime and across three difficulty bands (easy, medium, hard)—to act as the sole training pool.
   

3. Group Relative Policy Optimisation (GRPO)
   
   The ten samples were duplicated and permuted to form a synthetic mini‑corpus. GRPO fine‑tuning rewarded only perfect grid matches (1/0 signal), steadily raising the policy’s success on unchanged‑size puzzles to the mid‑80‑percent range.
   

4. Evolutionary refinement
   
   Each RL‑generated chain‑of‑thought (CoT) was passed to an evaluator LLM that produced fine‑grained scores on intermediate steps. Those scores fed an evolutionary loop that mutated, recombined, and re‑ranked CoTs, repeatedly boot‑strapping better transforms until the evaluator’s reward plateaued.
   

5. Deterministic program extraction
   
   The final CoT was translated into concise, deterministic grid‑manipulation code, ensuring reproducibility for judging.
   

Infrastructure Notes

They ran Initial experiments on Strong Compute Burst Workstations; once tested they scale‑up training on the company’s ISC cluster of H100 GPUs, spun up on demand within minutes. Built‑in hot‑swap utilities and cycling_utils functionality made it straightforward to patch issues without interrupting the 24‑hour clock.

Demo Day

During a ten‑minute slot, Arcified presented a concise slide deck: methodology overview, before‑and‑after solve counts, and a comparison showing their 85 % success rate next to the single‑digit scores typical of Gemini 2.5 Pro and OpenAI o3 on the same training samples. Judges highlighted the rigorous data sampling strategy and clear empirical gains.

What Comes Next

Arcified .AI plans to release their ARC Evolve code once additional refactoring is complete, extend experiments to larger reasoning models with 300–400 RL steps, and continue pushing towards a full public entry in the broader ARC Grand Prize later this year. They also aim to investigate whether multiple parallel traces of longer chains‑of‑thought yield further gains.

Acknowledgements

Vijayraj Gohil and Aditya Shah thank Ben Sand, Adam Peaston, Tim Smoothy, and Rebecca Pham at Strong Compute for rapid infrastructure support and guidance throughout the event.

Github Repo - https://github.com/vraj130/ArcEvolve

Slides -https://docs.google.com/presentation/d/17f3aFA1XEIFqLk9RSQbdeNM7v0Pou0xetJ2CNeMIugo/edit?usp=sharing

1. Introduction

Our overarching mission is to build a personalized AI tutor capable of delivering high-quality educational content to anyone, anywhere. We believe that true democratization of education can only be achieved by making learning deeply engaging, personalized, and universally accessible. A critical component of this vision is the ability to transform abstract questions into clear, visual explanations — a method proven to resonate more effectively with the way humans understand complex concepts.

In this hackathon project, we focused on one specific but essential challenge: automatically converting mathematical questions into visual animations using the Manim animation engine. The end goal is to empower students with dynamic visualizations that enhance understanding, retention, and conceptual clarity — especially in STEM education.

2. Problem Statement

Humans are inherently visual learners. Concepts that are difficult to grasp through text-based explanations can often be instantly clarified through animation or visual demonstrations. Despite the power of this modality, creating educational animations remains a time-intensive and highly manual process. Our challenge was to automate this pipeline: given a natural language mathematical question, can we generate a Manim animation script that explains the solution visually?

3. Initial Approach: Supervised Fine-Tuning (SFT)

We began by attempting a supervised fine-tuning (SFT) approach. Specifically, we fine-tuned the DeepSeek LLM using a dataset of input-output pairs, where:

• Input = a mathematical question

• Output = the corresponding Manim script to animate the explanation

We also attempted to incorporate Chain-of-Thought (CoT) reasoning in the outputs, guiding the model to not only solve the problem but also break it down into explanatory visual steps.

Challenges

However, we encountered two major limitations:

1. Lack of high-quality training data: Manim-query pairs are a highly niche and scarce dataset. Publicly available examples are limited in volume and diversity.

2. Absence of Chain-of-Thought (CoT) annotations: Even where datasets exist, few contain intermediate reasoning steps essential for generating coherent explanatory animations.

Due to these challenges, the SFT approach failed to generalize well and lacked visual accuracy and semantic coherence.

4. Proposed Solution: GRPO with Reward Modeling via Gemini as External Judge

To address these limitations, we pivoted to a novel reinforcement learning framework based on GRPO (Generative Reward Policy Optimization). Instead of relying on static data, we introduced an external LLM-based reward model — built on top of Gemini — to act as a judge of the model’s outputs. This model provided feedback on the quality of generated animations, enabling us to train the base model using reward signals rather than hardcoded labels.

Reward Model Criteria

Our reward model evaluated each generated Manim animation based on the following five criteria:

1. Prompt Consistency
   Does the animation match the original mathematical prompt in terms of objects involved, actions depicted, and conceptual correctness?
   

2. Screen Fit
   Do the visual elements stay within the canvas boundaries? Do any objects overflow or render off-screen?
   

3. Non-overlapping Layout
   Are the visual elements well-spaced? Do objects overlap in distracting or confusing ways?
   

4. Semantic Coherence
   Does the animation make logical sense? For example, do equations appear where expected? Are objects used in appropriate ways?
   

5. Clarity of Explanation
   Is the final animation pedagogically effective? Would a student find it helpful in understanding the concept?
   

These multi-dimensional reward signals allowed us to optimize for visual, spatial, and semantic quality — aspects that are difficult to enforce via traditional supervised learning.

5. Results and Observations

With GRPO and Gemini-based reward modeling, our model demonstrated significantly better convergence compared to SFT. Not only did the animations become more visually accurate, but the overall explanatory coherence also improved. The model was able to generalize across a range of simple mathematical prompts and produce clear, legible Manim animations with minimal hallucinations or layout issues.

6. Future Directions

This project represents just the beginning of our journey toward building a fully autonomous AI tutor. Moving forward, we plan to:

• Expand the complexity and diversity of supported mathematical questions (algebra, calculus, geometry, etc.)

• Integrate real-time preview and editing tools for generated animations

• Incorporate user feedback and corrections into the reward signal (RLHF loop)

• Extend support beyond Manim to other visual engines and modalities (e.g., interactive graphs, 3D geometry)
  

We are excited to continue developing this project with the support of StrongCompute, and look forward to pushing the boundaries of personalized AI education.

7. Acknowledgments

We thank the hackathon organizers and the community for providing a platform to explore such impactful ideas. We are especially grateful to Strong Compute for providing infrastructure and support.

This post was written by Karthik Ragunath Ananda Kumar, AI Researcher @ Tavus Inc, Bernett Orlando, Senior ML SWE @ Google Research and Ramprasadh Kumar, Systems @ NVIDIA

Links:

• Presentation slides: Google Slides

• Github repo: Link here

Unlike previous hacks where the focus was often on output accuracy or performance gains, Hack 9 was about how models get to their answers—whether through intermediate tool use, explainable steps, or even visualizations.

Deep Seek Highlights from Hack 9

Tool-Augmented Math Agents

One team built Agent R1, a reinforcement fine-tuned DeepSeek 1.5B model trained on GSM8K (a math reasoning dataset). By integrating external tools like Wolfram Alpha and leveraging RFT, they pushed a 1.5x improvement in accuracy. All tool calling was up and running cleanly—making this a strong example of how retrieval and symbolic computation can extend model reasoning without scaling parameters.

From Math to Manim

Another developed a text-to-Manim pipeline, where DeepSeek was used to generate math animations using the same Python library as 3Blue1Brown’s visual explanations. While currently using Gemini as an intermediate step, the team plans to replace it with a local model and explore reinforcement techniques like GRPO. This approach hinted at a hybrid of qualitative and quantitative understanding—offering the potential to make model reasoning visible, not just verifiable.

DeepSQL and Structured Semantics

We saw one team focus on generating SQL from natural language using DeepSeek and an augmented 9.4GB chain-of-thought dataset. By introducing schema-specific prompts and structure-aware validation, the team moved toward more semantically grounded outputs.

DeepBash and Code Generation

With NL2Bash data and DeepSeek 1.5B, this team targeted improved scripting capabilities. Their goal was a more intelligent shell assistant that goes beyond memorizing commands to understanding intent.

LawLoom: Legal Reasoning with LLMs

This project introduced a custom dataset in regulatory compliance and achieved a 4% accuracy bump over baseline models. Reinforcement fine-tuning with GRPO is on the roadmap, indicating continued investment in domain-specific reasoning and traceable outputs.

Iterative Reasoning Experiments

A team contributed a second DeepSeek-based demo aimed at abstract summarization and iterative training loops. His work hinted at bigger models learning chain-of-thought via bootstrapping—a promising area for future hackathons.

ARC Experiments and Abstract Reasoning

Hack 9 also saw renewed attempts at ARC-style abstract reasoning:

“We Have Our Reasons”

One project took a hybrid ARC/DeepSeek approach using a dataset of real-world software and logic problems, aiming to train the model to generalize reasoning patterns without overfitting to narrow benchmarks. Distributed inference and transpose operations were key techniques explored here.

“Outthinking the ARC” – by ClosedAI

This was the winning submission in the ARC-AGI-2 track and deserves its own spotlight. The team from ClosedAI documented their process in this write-up, which walks through their modular LIMO architecture, custom reasoning token blocks, and synthetic puzzle generation pipeline.

Their results? A 75% pass rate on training problems—well beyond the baseline 10–20%—with full task resolution in under a second per puzzle using Strong Compute’s Instant Supercomputer. This submission set a new bar for structured, explainable ARC performance.

Join us at the next hackathon. Builders, researchers, and experimenters — sign up now.

This past weekend, my team, ClosedAI, participated in the ARC AGI2 track of Strong Compute’s intense 24-hour hackathon—and we ended up winning! Here's a detailed look at our approach, the innovations we introduced, and the results we achieved.

What's ARC-AGI-2?

The ARC-AGI-2 benchmark, created by François Chollet, consists of 1,000 challenging visual puzzles designed to assess true abstract reasoning in AI. Human participants typically solve around 60% of these puzzles, whereas most existing AI models only manage between 10% and 20%. Each puzzle allows just two submission attempts, demanding high accuracy and generalization from minimal examples.

Our Strategy

Given the tight 24-hour constraint, we prioritized maximizing accuracy (pass@2) and computational efficiency. Our team divided the workload into two parallel streams: data augmentation and model architecture. Constant communication and rapid iteration allowed us to promptly resolve issues and share critical insights.

Our Implementation

Synthetic Data Generation with LLMs

We built an automated data generation pipeline using large language models (LLMs). Starting from minimal human-provided examples, we generated hundreds of synthetic puzzle variations per task. These were then filtered and clustered to ensure a diverse and comprehensive training dataset.

Custom Reasoning Token Blocks

To make our model’s reasoning transparent and easily debuggable, we introduced structured "token blocks." Each token block explicitly represented a distinct reasoning step, facilitating rapid error identification and correction.

The "Less Is More" Architecture (LIMO)

Inspired by recent research showing the effectiveness of minimal but precise prompts, we employed the LIMO architecture, consisting of:

• A primitive encoder converting puzzle grids into structured embeddings.

• A modular library of fundamental operations (rotate, mirror, count, color-match).

• A neural scoring mechanism selecting the most plausible operation sequences.

Results & Performance

Our combined approach achieved a 75% resolution rate on the training puzzles, significantly outperforming the typical AI baseline performance of 10-20%. Each puzzle was solved in less than one second, meeting the competition’s strict efficiency criteria.

Infrastructure Utilization

Leveraging Strong Compute’s Instant Super Computer (ISC) platform, we rapidly conducted parameter sweeps and experiments across numerous A100 GPUs. Automated end-to-end submission checks ensured quick identification and resolution of issues, maintaining seamless workflow continuity.

Lessons Learned and Future Directions

• Early Automation: Integrating automated end-to-end tests early on was critical in saving debugging time.

• Modular Design Advantages: Our modular and structured reasoning approach consistently outperformed monolithic models in accuracy and interpretability.

Future work will involve open-sourcing our synthetic data generation pipeline and reasoning token blocks, along with exploring meta-learning techniques for automatic reasoning strategy discovery.

Acknowledgments

We are grateful to Ben Sand, Adam Peaston, Tim Smoothy, and Rebecca Pham from Strong Compute for their invaluable support and mentorship throughout the event. Their assistance played a significant role in our success.

Written by Sanika Chavan, Mudit Sinha, Aman Priyanshu

Github repo link: https://github.com/sanikac10/Annotating-ARC-AGI-2/tree/main/Annotating-ARC-AGI-2-main

Join us for our next ARC Prize Hackathon in SF and Sydney: https://lu.ma/strongcompute

The most exciting projects aren’t just clever — they’re grounded. They tie model output to something you can check. A compile. A benchmark. A math proof. A correct answer, not just a convincing one.

That’s a subtle but powerful shift. A lot of machine learning treats model output like a good guess — probabilistic, fuzzy, often right but not always reproducible. These projects took a different approach: don’t just generate something — generate something you can verify.

And the difference shows.

No Hallucinations

We’ve seen a move away from the traditional “trust the model” mindset toward something more rigorous: can we prove this works?

This is especially important in code generation, scientific reasoning, and anything where correctness matters. When you’re training or fine-tuning on tasks that involve real-world outcomes — not just vibes — you need more than confidence. You need certainty.

At our March hackathons, we saw CUDA and Math Fine Tunings that show provable deep learning is practical:

CUDA Codegen from PyTorch Modules

One team built a smart transpiler that takes PyTorch modules and converts them into CUDA kernels. The model generates CUDA code and then evaluates each candidate across three dimensions:

• Does it compile?

• Does it produce the correct output?

• Is it faster than the original?

This is a huge unlock. Because now, instead of relying on token-by-token loss or human labels, you can score the model’s output based on reality. Compilation success becomes a training signal. Runtime performance becomes a benchmark. And correctness becomes a pass/fail gate.

They used a method inspired by DeepSeek — sampling multiple CUDA candidates, scoring them relatively, and feeding that back into training via group-relative policy optimization. It’s reinforcement learning with a feedback loop rooted in physics, not language.

Results (from Fine Tuning Llama DeepSeek7B on 8x L4s through Strong Compute)

Check out the winning team’s presentation here.

Mathematical Reasoning with Python Tool-Calling

Another project focused on mathematical reasoning — but with a twist.

Rather than having the model do all the work internally (and risking a hallucinated equation), it called out to Python tools mid-inference. For example, it might solve part of a problem itself, then delegate the numerical computation to a verified function.

This kind of delegation is exciting. It opens the door to integrating with formal verification tools like Lean— not just solving math problems, but producing verifiable, explainable proofs.

In practice, mathematicians don’t just want to know if something is true. They want to understand why. The model becomes a co-pilot, helping construct the steps — not just giving you a binary answer.

• Check out Karthik and Divya’s presentation

• GitHub Link For Fine-tuning: https://github.com/Karthik-Ragunath/isc-demos-karthik/tree/main/deepseek

• Inference Code: https://github.com/Karthik-Ragunath/isc-demos-karthik/blob/main/deepseek/inference_consolidated.py

Why This Matters

Verifiable machine learning isn’t just a niche — it’s the direction the field needs to go.

We’ve all seen what happens when models are powerful but ungrounded. Outputs that look right but aren’t. Answers that sound convincing until you test them.

These projects — and the teams behind them — are showing what it looks like to go beyond that. To treat model outputs not as a final product, but as hypotheses. And then build systems that can validate them, at speed.

We want Strong Compute hackathons to keep pushing in this direction: ideas that are smart and measurable. Tools that show their work. Models that can be trusted because they’re tested.

Join to Hack on ARC Prize or Fine-Tune Deep Seek April 18–19.

We’re bringing the GPUs and the hacker house energy back again.

Whether you choose to push the frontier on reasoning (ARC Prize) or scale a smarter distillation demo (Deep Seek), we’ve got clusters, food, desks, and a clean training setup ready for you.

Previous Winners and Grantees:

• PyTorch → CUDA Fine-Tuning: Improved translation accuracy from 10% to 30%.

• ARC Prize: Our grantee placed 2nd in the 2024 ARC contest.

• Chess Bots: Trained from scratch to 2000 ELO in just 10 hours.

For engineers, AI researchers, students — anyone comfortable with PyTorch.

We provide the Instant Super Computer (ISC), so you can start training multinode in under an hour. No setup headaches. No fuss.

Engineers only. All code. No slidegineers or recruiters. All applicants vetted for technical fit.

Competition A: ARC Prize Challenge

• Compete to win compute for the 2025 ARC Prize

• Work on unsolved ARC-AGI-2 tasks with full resources and benchmarks

• Judged on research rigor, novelty, and benchmark performance

Competition B: Deep Seek Fine-Tuning

• Fine-tune DeepSeek-R1 distill variants on your dataset

• Show what your model can do that the base model can’t

• Model sizes: 1.5B to 70B — all provided

Prize: $2.5K–$25K Research Compute Grant

Let’s push the frontier — together.

Apply now — see you April 18-19.

This naturally puts new entrants at a disadvantage, having comparatively less experience on Strong Compute and with the Chess Hackathon repo, so for our last round, we ran a Novices league and a Veterans league, then played the best of each against each other.

The winner of the Novice leave was team ThetaHat (Gopi Maguluri & Venkatachalam Subramanian Periya Subbu) and the winner of the Veterans league (also the overall winner) was Neural Knight (Pang Luo).

These are their stories.

Ramblings on the Chess Hackathons
Pang Luo (Neural Knight)

My chess agent, Neural Knight, won the Strong Compute November 2024 Chess Hackathon Championship. Here’s a recap of the journey.

In the October hackathon, I started with a Graph Neural Network (GNN) model to play chess but encountered challenges with data, modelling, and the training script. I switched to a Computer Vision (CV) model provided by Strong Compute, featuring standard components like convolutional layers, batch normalisation, dropout, and linear layers. After training on a dataset of approximately 350,000 grandmaster games for seven hours on a 48-GPU cluster, the model placed second. While it performed reasonably well in the opening and middle games, it still made blunders in the endgame - once even failing to capture a queen.

For the November hackathon, I considered adding heuristics to prioritise moves like checkmates, captures, and promotions. Though allowed, it felt misaligned with the competition's spirit, so I abandoned the idea. Instead, I focused on extending the training time, curious whether a longer training period would yield better results than algorithm tweaks. I also resumed work on my GNN model, writing a new training script.

The CV model was trained for over 15 hours—double the duration of the initial attempt - resulting in improvements in both metrics and gameplay. While some blunders remained, they were less frequent. The model now deserves thorough testing against the earlier version to confirm its superiority. Meanwhile, I plan to continue developing the GNN model for future competitions.

A huge thanks to the incredible Strong Compute team for their stable systems, abundant GPU

resources, excellent technical support, clear documentation, smooth logistics, and - of course - fantastic food!

Maybe Attention is All You Actually Need!

Our team theta hat recently won the Novice League winning the recently concluded 5th Chess GPU hackathon organized by Strong Compute. We had multiple teams from San Francisco and Sydney competing to build a chess playing model. We faced multiple teams in the tournament where we witnessed our model playing against other chess models developed by the participating teams. It was an exhilarating experience watching computers compete against each other.

The first step

The first step in our process was to thoroughly familiarize ourselves with the two base model architectures provided: Chess GPT and Chess Vision. To ensure a strong foundation, we carefully reviewed the case studies and blog posts written by previous team members. This allowed us to learn from their experiences, insights, and approaches. Additionally, we analyzed the strategies of past winners, leveraging their successes to guide our efforts and maximize our chances of success.

We totally believe that learning from best practices by past teams allows avoiding common pitfalls, learning what is done right and definitely increasing the chances of success.

From our readings we decided to go with the Chess Vision model. Immediately we trained the base architecture and pulled up a checkpoint and made the model play against itself. Watching the model make moves and compete with itself was just insane!

Building the model

“Complexity is the enemy of execution” quoted by Tony Robbins was the mantra to our success. Sometimes, complicating things makes things worse. From our experience, we learnt that more often than not adding multiple components, features and layers to our model makes the model harder to train. Overcomplicating things can lead to confusion, while simplicity helps the model focus on the essentials and learn more effectively.

Keeping this in mind, we went on to add 2 game changing layers - Self Attention and Squeeze Excitation (SE) blocks.

The SE block is a mechanism used in computer vision deep learning models. It is that layer that helps deep learning models to focus on important features ignoring the less important features/channels.

As in chess, all pieces are not of the same value, similarly not all features or channels (the different layers or dimensions of features that are learned by a model when processing data) are not equally important. We value some pieces and positions more than the others. Similarly, we wanted our model to understand what piece, moves or position is important in a given circumstance rather than treating the entire input equally. The SE block essentially asks “Which feature or channel are most important to understanding the chess board and its state and how can we focus more on the important parts?”

The Attention layer is a similar layer to the SE block. The SE block helps to understand the most important feature, but the attention layer is what actually helps the model to focus on specific regions of the chess board, such as certain pieces, moves and positions or board areas. The SE block has feature level awareness and the Attention layer is spatially more aware meaning it focuses more on the positions and pieces. The attention layer essentially asks the question “What portion or part of the chess board should I focus on for the current move?”

Evaluation Phase

We considered multiple checkpoints based on both training and validation loss convergence. Model validation, the process of selecting the best model, is crucial, as we must recognize that simply “more training does not always imply better results.” In fact, excessive training can sometimes lead to overfitting, leading to poor generalization.

This naturally leads to the question: “What is the best way to identify the best model?” There are many approaches to this, but we chose the Strong Compute way. We had our selected models (from different checkpoints) compete against itselves, as well as against models from other checkpoints under consideration. When the model competed against itself, we focused on scores where White : Black was 0.501 : 0.499, indicating balanced performance. When competing against other models, we chose the one with the highest score.

Additionally, we had our model face off against the Stockfish engine. The model that performed best in this battle was chosen as our final model for the tournament.

Our Experience Overall

It was galvanizing to see models making chess moves and battling against each other. Further, the experience of using not 1, nor 2, but 48 GPUs as a cluster was a unique experience. This was something we had never done before and are extremely happy to experience and use.

The hackathon was not only a good learning platform, but also a very good networking one. We got to know many people in the industry and several like minded individuals fascinated about technology and its potential.

Furthermore, we are looking forward to utilizing our $10K of credits for the betterment of technology.

Acknowledgment

We are extremely grateful for the opportunity to participate in the hackathon, which was filled with memorable experiences and valuable learning. Our heartfelt thanks go to Ben Sand for providing this opportunity, Zac Saber and Rebecca Pham for their technical support, Adam Peaston for hosting such a fun and exciting tournament, and the entire Strong Compute team for their unwavering hospitality.

Join us for our final event of 2024

It’s time to see if “Attention is All You Actually Need!” After five incredible rounds of fierce AI competition, our Chess Hackathon has become a hub for veterans and newcomers alike, pushing the boundaries of chess-playing AI.

Sign up now for our last Chess Hackathon of the year and Christmas party on December 13-14! Register here: https://lu.ma/strongcompute

Our entire Australian engineering team will be in town—don’t miss the chance to join the fun, network, and compete with the best. See you there!

Insite is developing AI monitoring for Construction Projects.

The development approach used many university research teams (160 developers) to prototype solutions.

A large scale up of compute management was needed.

Cian, founder of InSite Project Solutions, needed to manage 160 university students across 26 AI research teams - a massive expansion from previous years. He faced a critical infrastructure challenge. His existing in-house compute setup of 3-4 GPUs couldn't support this scale of concurrent AI development, placing timeline and resource risk on developing computer vision models for construction sites.

Project Goals

Radical improvement to construction site monitoring through AI-powered, ultra-high-resolution imagery analysis. The solution delivers:

• 24/7 monitoring with unprecedented detail, capturing site activity up to 800 meters away

• 80% improvement in AI model performance using 64megapixel imagery

• 6-10x cost reduction compared to traditional on-site project planning

• Real-time analytics and comprehensive reporting for construction managers

Previous Infrastructure Limitations

Without the Strong Compute, InSite’s AI developers faced significant technical hurdles:

• Limited GPU availability creating research bottlenecks

• No job scheduling system, leading to a "first-come, first-served" chaos

• Resource conflicts with teams frequently hitting "CUDA Out of Memory" errors

• Performance degradation from concurrent workloads

The Strong Compute Solution

Strong Compute enabled Insite's research capabilities by:

• Seamlessly scaling from 4 to 60+ GPUs

• Eliminating infrastructure management overhead

• Providing robust job scheduling and resource allocation

• Enabling true parallel research across 26 teams

Business Impact

"It just worked in the background," says Cian. "I didn't need to manage it. I just set up the accounts and the users went in and used it. I didn't need to get in and fix it if it broke or set it up or whatever. It just worked."

Strong Compute enabled Insite Project Solutions to:

• Successfully manage an 8x growth in AI researchers.

• Accelerate development of cutting-edge computer vision models

• Avoid expensive cloud computing costs and complex cloud configurations

• Focus on innovation instead of infrastructure management

Why Strong Compute?

Strong Compute proved to be the perfect solution for scaling AI research operations:

• Zero infrastructure management overhead

• Immediate access to massive GPU computing power

• Cost-effective alternative to cloud providers

• Built-in safeguards against runaway computing costs

• Seamless onboarding for large research teams

Using Strong Compute, Insite Project Solutions transformed a potential operational nightmare into a seamless research operation. This enabled breakthrough innovations in construction site monitoring while managing a record number of concurrent AI development teams.

AI compute that is running on near free energy and not putting any demand on our grids on Earth.

This our long range vision at Strong Compute. 

Today, we’re working on the best way to use compute on Earth, but not too far from now, we’re looking much bigger.

We're looking towards Sol, because we believe that broadly accessible AI compute isn’t just about breaking down barriers here on the ground. It’s about setting humanity up to thrive, and to do that, we need much more than Earth can, or should, provide.

How it Started

I started in technology building computers in my bedroom as a kid, and some years later had knocked together thousands of them - some with a focus on price, others with maximum speed as the goal, or the best in reliability. 

From there, I got into startups, augmented reality hardware, residential hackathons, and then Strong Compute. 

Along the way, I realised there was a deeper goal worth chasing: freeing people from the constraints of compute power so they could innovate at will. Strong Compute’s mission is exactly that—we’re here to make it feel like all the compute power in the world is plugged directly into your laptop. And we’re nearly there :-).

At Strong Compute, we want your machine learning workloads to scale effortlessly. No more worrying about infrastructure, pipelines, or cluster configurations. Just pure, unfettered creativity, where you can spend your time experimenting and pushing boundaries.

And for the execs reading, this is here to make your life work as well - a complete live picture of all AI resources in your company, the ability to limit costs on any dimension, and a much more attractive place for AI talent to work.

Strong Compute: Speed.

A great developer experience means removing clutter from your workflow (ie. ops) and giving you the best reactivity possible.

We’ve hit record-breaking speeds on commodity clusters with 90 GB per second file read, 60GB/sec from object storage to cluster and 20GB from object storage to a single instance. This is all purely software and runs on commodity cloud. No specialised hardware is required.

We’ve built the world’s fastest container registry, so you can pull a 70 GB container onto a machine and have it running in under 10 seconds.

These numbers are hundreds to thousands of times faster than what most people experience today. And we made it cheaper too. As much as 10x lower cost than many widely used options.

Raw speed is great, but the ability to iterate quickly as a dev means not waiting on management decisions as well. You want a lot of compute and management wants to not break the bank.

We’ve made it insanely simple to keep tabs on costs. You get complete control over your compute spend, which means no surprises.  Integrate multicloud bill caps. Spend allocation across any combination of instances. Stop being constrained to one box on one provider in one region, and at the same time, no more sudden bill spikes because you forgot to cap usage—we make that easy.

You can watch your compute jobs spread across the world, visualize the whole team’s usage, and move workloads around any providers clusters however you need.

Want to give it a go? Join our next Chess Hackathon, a perfect chance to experience Strong Compute in action. Bring your AI ideas, take on our high-performance clusters, and watch your chess bot compete live.

Who’s Using This? Pioneers on the Edge of AI

We’re fortunate to work with some of the most forward-thinking researchers and developers around. From training human neural tissue in petri dishes to work like an AI chip, to exploring new alternatives to gradient descent, our users are breaking new ground in AI. No wrappers here. 

One team in Berkeley is even modeling social science questions by training language models to reflect the behavior of different populations.

Each month, we run hackathons and provide research grants from $10K to $100K, putting our resources in the hands of people breaking new ground in AI. If you’ve got an idea that would shake how things are done today, we want to fund it.

Want to hear more about this vision? Watch my full talk on how democratizing compute and the Dyson sphere vision come together.

Let’s Talk Dyson Spheres

Here’s where I get most excited. AI compute needs power, and lots of it. We’re seeing demand skyrocket—but what if we could access an energy source that’s virtually unlimited? 

Enter the Dyson Sphere concept, an inspiring concept first proposed by physicist Freeman Dyson: build a massive cluster of structures around the sun to capture nearly all of its energy. Think about that—all the energy we’d ever need, without impacting Earth’s resources or environment.

It sounds like science fiction, but it’s not. Moving compute infrastructure into space is the first step, lowering our dependence on Earth’s finite resources and lack of willingness to keep a solar panel in sunlight 24x7. And the energy potential is staggering. Right now, the sun emits about two billion times the energy that hits Earth. In space, solar doesn’t need batteries. With a Dyson Sphere, we’re talking about harnessing nearly all of that energy to fuel AI compute. 

Want to be part of this conversation? Join our Dyson Sphere Discord server to dive into the future of compute and space-based infrastructure.

Energy Possibilities on the Final Frontier

NASA’s Parker Solar Probe has already shown that we can get close to the sun—it’s currently orbiting nearer to our star than any previous human-made object. The energy per square meter is 600 times greater there than in Earth’s orbit. That’s 600 times the power for the same hardware! With thermophotovoltaics, a less developed type of solar panel than regular PV, we could capture this energy even more efficiently in these extreme conditions. TVP has a theoretical maximum efficiency of 85% and we need scientists focused here as the future of addressing humanity’s energy demands.

Space Infrastructure is Here (Almost)

Other companies are catching on to this vision too. Lumen Orbit, is planning low-Earth orbit data centers, where energy could be as cheap as 1 cent per kilowatt hour. And AstroForge is developing asteroid mining technology, making it possible to source resources from space, for space. The future is infrastructure is not on Earth.

Now, building close to the sun won’t be easy. We need about 30-60 km per second of Delta V to reach a stable orbit there,  But thanks to reusable rockets like SpaceX’s Starship, we’re not far off. And existing railgun technology can work at the speeds needed to bring infrastructure from Earth orbit to the sun likely much more cheaply than a flotilla of chemical rockets. Starship can carry the resources from Earth to establish and supply our sun focused transport network.

A Call to Dream Big with Us

At Strong Compute, we’re here to dream bigger than the present allows, pushing the limits of compute to the edge of what’s possible—and beyond. We’re building a future where anyone can access the compute power they need, on demand, without limits. We’re starting here, on Earth, and the Dyson Sphere is where we’re headed.

So if you’re ready to be part of this journey, apply for a research grant, get early access to Strong Compute for your organization, join one of our monthly hackathons, and see what’s possible when compute has no friction.

Occupy Sol. 🫡