New starter pack: Performance Engineering & Systems The people focused on how software actually runs. Performance, optimization, and the runtime layer where efficiency is determined. go.bsky.app/2oBQ94W

The future of compute efficiency isn’t just better chips. It’s software that uses them intelligently. #SelfAwareCompute

Most energy waste in compute isn’t hardware. It’s unnecessary work. Wrong execution paths Inefficient loops Over-allocation Fix execution → fix energy. #Efficiency

This whole AI push is feeling more and more unsustainable. Investors pouring money into compute Power grids getting stressed Water use climbing Costs rising And at the same time, we’re automating the bottom of the job ladder Feels like a lot of pressure building in one place.

Data centers already consume hundreds of terawatt-hours of electricity. And it’s doubling fast with AI. We don’t have time for inefficient execution. #Energy #AI

Imagine deploying code and already knowing the exact performance profile. No surprises. No guesswork. #TechInnovation #SelfAwareCompute

Sharing something from the Fathym team: Every AI session builds context. Then you lose it. Switch tools, start over, repeat. Fathym's FAI changes that. #Fathym #FutureOfTechnology

We’ve never had real predictive models for software execution. We had: • estimates • benchmarks • profiling after the fact But not true prediction. That changes everything. #EnergyOptimization #RuntimeOptimization

What if you could know before running code: • how long it will take • how much memory it needs • how much energy it will use That’s the foundation. Prediction → control. #AI #Software selfawarecompute.com#optimization

SelfAware Compute maps execution into pathways. Then it can: predict behavior choose better execution optimize for your goal Before and during runtime. #Software #Systems #Compute #Engineering

Every time your software runs, it’s a different execution. Different: branches loops memory access timing But we treat it like it’s the same. That’s where inefficiency comes from.

Compilers optimize instructions. But software doesn’t run as instructions. It runs as execution pathways. Different inputs → different pathways → different time, memory, energy. Most systems ignore that.

New starter pack: AI Infrastructure The companies and people building the backbone of modern AI. Training, inference, scaling, and deployment. go.bsky.app/LWwfhAF

We’ve spent decades improving hardware. Now it’s time to improve how software runs on it. SelfAware Compute selfawarecompute.com #SelfAwareCompute #FutureOfCompute

Question: If your software could • reduce energy • increase performance • adapt in real time What would you optimize for first? #PerformanceEngineering

Sovereign cloud is pushing compute back toward localized, controlled environments. That means less uniform infrastructure and far more variability in how software performs. The interesting question is what happens when optimization has to adapt to every environment, not just one?

New category: SelfAware Compute Software that understands how it runs and optimizes itself accordingly. #NewCategory

Everyone talks like AI limits are just compute. They’re not. Energy. bandwidth. memory. physics. It’s how these resources get extracted, built and deployed. Then it’s how we adapt software around those constraints… or work around them entirely. youtube.com/shorts/wvzJH...

This pattern shows up a lot. “Just one more year” has a way of piling up over time. At some point it stops being about the tools and starts being about how hard the system is to actually change.

Billions in data center projects are being delayed or blocked as communities push back on energy, cost, and impact. When those same constraints keep showing up, it starts to feel like infrastructure alone isn’t the whole answer. Probably means the software layer has to change too.

We believe the future of software is: Not faster code Not bigger models But code that understands itself. #Future

We're building the engine to make AI run more efficiently - from energy to apps. #SelfAwareCompute #SustainableComputing #ComputeEfficiency youtube.com/shorts/SxoTO...

Stop throwing hardware at inefficient execution. #HotTake

Parallelization was about doing more at once. SelfAware Compute is about doing only what’s necessary. That’s a very different idea. #Software

This isn’t: • a new programming language • a new chip • a new framework Self-Aware Compute works on existing systems. It changes how software executes. #Tech

We’ve been scaling hardware for decades. More cores More GPUs More power What if instead… we made software smarter about how it runs? #FutureOfCompute

Compute cost = product viability. Get it right → scalable margins Get it wrong → lose money per user Execution efficiency is now a business problem. #Startups #AI

New starter pack: Energy + Compute Efficiency Compute is now constrained by energy. And inefficiency shows up as cost. These are the people thinking about how systems actually scale under real-world limits. go.bsky.app/Ui89jmu

AI isn’t just a model problem. It’s an energy problem. Inference is now the majority of compute—and it runs constantly. Every inefficiency = real cost. #AI #Energy

Software runs blindly. Execution isn’t static. That’s about to change. #SelfAwareCompute

Same code. Same hardware. Different inputs. → Completely different execution behavior But today, software treats them the same. That’s inefficiency at scale. #AI #Systems

Most optimization today is static. Compilers optimize once. Then execution is fixed. Self-Aware Compute is dynamic. It adapts every time software runs. #Engineering

Self-Aware Compute means software can: • understand execution pathways • predict time + memory before running • optimize based on goals (energy, speed, cost) Not guess. Not approximate. Understand. #Tech

Fascinating - “The companies doing everything ‘right’… came in second.” There’s a balance: core functionality has to work end-to-end but optimizing everything too early slows you down. Thanks for sharing your research.

Wild that we can: • train trillion-parameter models • simulate physics • generate video …but can’t answer, “How long will this code take to run?” #DeveloperThoughts

April 14 has been designated World Quantum Day in honour of Planck’s Constant which can be rounded to h~ 4.14×10−15 eV·s (and some folks write April 14 as 4/14*). 🧪🐡🎢 Planck’s constant comes up a lot in quantum mechanics; for instance a photon’s energy is h times its frequency). 🧵

Data centers used ~460 TWh of electricity last year. And it’s accelerating fast. We don’t have a hardware problem. We have an execution problem. #Energy #AI

Future of software execution starter pack: • Execution ≠ static • Inputs change everything • Efficiency is the constraint • Energy = cost • Runtime is where it matters Most software still runs blind. That’s about to change. #SelfAwareCompute

Software today is “compile and pray.” You compile once → assume performance → hope it works across all inputs But: Inputs change Systems change Workloads change Execution doesn’t adapt. #SoftwareEngineering

Compute is becoming the most constrained resource in the world. Not storage. Not bandwidth. Compute. And we’re still running software blindly. That’s the problem. #AI #Infrastructure

What if software could see its own execution? Not logs. Not traces. Actual understanding of: • what runs • how long it takes • how much energy it uses Then optimize itself in real time. That’s SelfAware Compute. #Compute #AI

Software that finally understands how it runs. For decades, software has executed blindly. Same code. Same compile. No awareness of what actually happens at runtime. Self-Aware Compute changes that. #SelfAwareCompute #Software