Friday, August 7, 2026

Terminators at the Terminator

The nicest thing about the word terminator is that it already sounds like a machine sent back from the future to explain your capital expenditure problem, or to make you realize the capital expenditure will not save you from a distant AI dominated dystopian doomsday.

In orbital mechanics it means something calmer and stranger: the line between day and night. A dawn-dusk sun-synchronous orbit rides that line around Earth, keeping the spacecraft in near-continuous sunlight. For Earth observation satellites this is useful because the illumination geometry stays predictable. For solar-powered orbital infrastructure it is more tempting: maximum duty cycle, fewer battery cycles, and the delicious thought that your data center can spend most of its life with the Sun on tap.

So yes, the terminators at the terminator. AI training and inference workloads running in low Earth orbit, fed by photovoltaics, cooled by radiators, and connected through optical links to ground stations and other satellites. A nice science-fiction phrase once you have solved the heat and materials balance to get up the gravity well.

The dawn-dusk sales pitch

The pitch is not silly. It starts from real constraints.

AI data centers are going to become giant electrical-to-heat converters with a side effect of model weights. Reminds me of the time when I used to dry my laundry on my bitcoin miners. On Earth we feed them through grids, substations, diesel backup contracts, cooling towers, chillers, water rights, fibre backbones, and increasingly awkward community meetings. In orbit you can imagine skipping some of that. Put the compute near continuous sunlight. Use high-efficiency solar arrays. Use direct-to-space radiators instead of evaporating water or warming a river. Place inference near space-borne sensors. Put pre-processing close to Earth observation instruments so the useful bits come down instead of the whole firehose.

NVIDIA’s Vera Rubin platform is the more immediate reference. Vera is the CPU and Rubin is the GPU, assembled with networking, memory, and rack-scale infrastructure as the successor generation to Blackwell. The roadmap promises another large increase in AI training and inference throughput, but throughput arrives with denser power delivery, cooling, and interconnect requirements. An orbital operator would inherit the useful work per watt and every unresolved watt of heat. Rubin therefore belongs in the radiator calculation as much as in the model-training benchmark.

Sensor-side inference offers a different use for that compute. The instrument looks down, the processor sits nearby, and the network carries detections, embeddings, tiles, compressed products, or model updates instead of raw sensor exhaust. A satellite constellation does not want to be a fleet of USB drives with antennas. It wants to be a distributed science platform with a power budget.

That is where dawn-dusk orbit starts to look like a scheduling primitive. Solar availability shapes the compute cluster. Training jobs, inference bursts, checkpointing, downlink windows, thermal soak, battery reserves, and radiator orientation all become part of the same planner.

The cloud scheduler gets an ephemeris.

The thermal model is the business model

On Earth, a data center engineer can cheat emotionally because air exists. It may be hot air, badly ducted air, or air pushed around by fans with punishing maintenance schedules, but it is there. You can move heat by convection. You can move it into water. You can bury part of the problem in a cooling tower plume and another part in a utility bill.

In orbit, there is no convenient atmosphere to carry the embarrassment away. Heat leaves by radiation, which puts the radiator alongside the processors and power supply in the core computer architecture.

The governing shape is brutally simple:


P = ϵσAT4

Radiated power depends on emissivity, area, and the fourth power of absolute temperature. Want to reject more heat without growing a ridiculous radiator? Run hotter. Want to run hotter? Your semiconductors, packages, solder joints, optics, interconnects, dielectrics, memory, and power electronics all need to tolerate it. A space data center is a semiconductor materials problem wearing solar panels.

This is why the recent attention around high-temperature semiconductors is interesting. Wide-bandgap devices such as silicon carbide and gallium nitride are already changing terrestrial power electronics because they switch efficiently and tolerate higher temperatures than conventional silicon in many roles. Push the idea further into ultra-wide-bandgap materials, diamond substrates, high-temperature packaging, and radiation-tolerant device physics, and the space qualified semiconductor variant emerges: hotter electronics can make every square metre of radiator work harder.

But that sentence hides several doctoral theses and a lot of broken hardware.

A transistor surviving a hot test coupon proves very little about the complete system. The whole compute stack has to behave: memory retention, timing margins, optical alignment, thermal cycling, electromigration, single-event effects, packaging stress, and the boring connectors that always become interesting at the worst possible time. Better high-temperature semiconductors help, but orbital data centers need a complete materials and packaging stack. A spectacular junction-temperature result does not provide one. We do not have the advanced PDK’s or foundries to do this today, but definitely a warm blue ocean of high temperature hardware to swim into.

Insulation is not the opposite of cooling

The intuitive mistake is to think space is cold, so cooling must be easy.

Space is not cold in the way a cold beer is cold. Space is mostly empty. A surface in sunlight gets blasted by roughly 1,361 W/m^2 before geometry and efficiency. A surface looking into deep space can radiate beautifully, but only if it is allowed to see deep space and only if the heat can get there.

So the architecture becomes a discipline of separation. Keep solar absorption away from the radiator side. Keep hot compute planes thermally connected to heat pipes, pumped loops, or thermal straps. Keep sensitive optics and timing hardware isolated from thermal gradients. Use multi-layer insulation where you want less radiative coupling. Use high-emissivity radiator coatings where you want more. Stop random structure from becoming a thermal short. Decide what gets to be warm, what must stay stable, and what can swing through orbital day-night transients without walking itself out of calibration.

In a dawn-dusk orbit, you buy continuous solar availability, but you do not buy a waiver from geometry. Solar arrays want one orientation. Radiators want another. Antennas and optical links want line of sight. Drag wants attention. Radiation shielding wants mass. Stationkeeping wants propellant or electrodynamic cleverness. The thermal design is coupled to everything else.

The radiator is not downstream of the business plan. It is in the first spreadsheet , or Claude conversation if you are not that good at maths.

Light moves from power source to processor

Orbital thermal constraints give optical computing a practical job beyond producing laboratory headlines.

The ENGtechnica write-up on Microsoft’s analog optical computer points at a useful direction: micro-LED arrays, spatial light modulators, and photodetectors doing vector-matrix operations in analog form, paired with a digital twin. The article claims promising results across image classification, nonlinear regression, MRI reconstruction, and financial modelling tasks, with Microsoft estimating up to 100x the energy efficiency of leading GPUs for suitable workloads.

The prototype is a specialised machine for particular AI inference and optimisation workloads, not a general-purpose replacement for digital computers. That narrow scope suits orbital compute, where general-purpose waste carries a physical penalty. Every joule that enters the box becomes a thermal export problem. Every ADC, DAC, memory movement, SerDes hop, and cache miss consumes both time and radiator area.

If you can do part of the workload optically, with fewer electrical conversions and less heat per useful operation, you change the orbital equation. Not enough to abolish thermodynamics, but enough to move a design from absurd to maybe annoying. That is a respectable improvement category in space engineering. Optical compute has the advantage of moving in fun new directions , couplint with the advances in quantum photonics or directly to laser comms module to get data off compute nodes to earth or between compute nodes in orbit.

There is a broader lesson here too. We keep treating compute as abstract symbol manipulation, then acting surprised when the factory bill arrives as heat. Landauer’s principle gives the tiny theoretical floor, kTln 2 per irreversible bit operation, but modern compute lives many floors above that. The practical losses are in data movement, leakage, switching, conversion, cooling overhead, and the human decision to train another model because the previous benchmark table had one unclaimed column.

Bits are not immaterial. Organising them has a thermodynamic cost.

Training, inference, and the ugly logistics of usefulness

Orbital AI training sounds glamorous, but inference is probably the more immediate fit.

Training wants enormous, tightly coupled clusters, rapid hardware refresh, dense networking, fault tolerance, huge data ingestion, and painful amounts of memory bandwidth. It wants technicians nearby when the expensive thing throws an unhelpful error. It wants the newest accelerators, because model economics are tied to performance per watt and performance per dollar, and both curves move quickly.

Inference near sensors is cleaner. Detect the smoke plume, ship the alert. Find the illegal fishing vessel, ship the track. Segment the flood boundary, ship the polygon. Compress the asteroid candidate stream before the downlink becomes the bottleneck. Turn imagery into geospatial events and only send raw data when the event deserves it.

Training still has a role, especially for models tuned to orbital sensors, onboard compression, anomaly detection, or autonomous operations. But the training argument has to survive hardware obsolescence. A terrestrial data center can swap GPU generations with forklifts, technicians, and a recycling vendor who may or may not deserve the word recycling. An orbital data center has a worse version of the same problem: the expensive solar arrays, radiators, pointing systems, communications hardware, and orbital slot may still be useful after the compute payload becomes embarrassingly old.

That is the stranded asset problem in orbit.

The answer cannot be to throw away the whole platform every time NVIDIA, AMD, Intel, Cerebras, Groq, Google, Microsoft, or some optical-compute startup moves the Pareto frontier. The more plausible architecture separates relatively static infrastructure from rapidly ageing compute: power bus, radiator fields, optical comms, attitude control, and docking interfaces on one side; replaceable compute, memory, and storage modules on the other.

In other words, orbital data centers need boring maintainability before they need cinematic scale like on the cover of latest IEEE Spectrum.

Close the silicon loop or don’t build it

A space data center that cannot be serviced is just delayed debris making a business case for companies like Paladin Space. When a territory politician asks over dinner why she should care about space, I can scare her by saying if she doesn’t orbital data centers will be falling through her roof. A risk that is uninsurable since the probabilities cannot be measured, and not suable against because the counter party is in China.

If we build orbital compute infrastructure, the end-of-life story has to be in the architecture from the beginning. Decommissioned compute modules need capture, removal, refurbishment, recycling, or controlled disposal. Radiator booms and solar arrays cannot be left as heritage sculpture in useful orbits. A failed training cluster should not become a fragmentation risk with tensor cores.

This is where orbital manufacturing stops being a novelty and starts looking like maintenance infrastructure. Silicon manufacturing in space has been discussed for reasons that range from microgravity crystal growth to vacuum processing and contamination control. Some of those benefits may turn out to be niche. Some may be overwhelmed by launch logistics and process control. But if the orbital asset base grows, the question changes from “can space make a perfect wafer?” to “which parts of the silicon, packaging, repair, and recycling loop are worth closing off Earth?”

Maybe the first useful loop is not wafer fabrication at all. Maybe it is inspection, module swap, radiator cleaning, connector replacement, board-level refurbishment, propellant top-up, or recycling aluminium structures. Maybe high-value semiconductor steps stay terrestrial while bulky static infrastructure stays orbital. Maybe microgravity does matter for particular crystals, optical components, or thermal interface materials. The answer should be found by process engineers, not by a launch animation.

But the principle is clear enough: keep the slow, massive, durable assets in place; rotate the fast-moving compute through them. Do not strand the power, cooling, networking, and orbital mechanics every time the accelerator roadmap changes.

The Earth is in space too

The tempting conclusion is that orbital data centers are exotic because they have thermodynamic problems. I think the opposite is true. They are interesting because they make the thermodynamic problems visible.

Earth-based data centers are also bounded by energy, entropy, materials, and waste heat. They just have more ways to export the consequences. A conventional data center can dump heat into air, water, district heating loops, neighbouring property, local weather, or a permitting process. Private property law lets the operator draw a fence around the useful part of the machine and call the heat someone else’s problem.

Physics does not recognise the cadastral boundary.

At planetary scale, Earth cools the same way an orbital data center does: by radiation to space. There is no cosmic cooling tower waiting outside the atmosphere. Add energy demand, trap more outgoing infrared, move heat around with clever plumbing, and the final balance still ends at the top of the atmosphere.

The terminator dual-meaning feels like a meme pill I have given myself. A data center on the dawn-dusk line cannot hide behind convection, and a data center in a suburb cannot hide behind property law forever. In both cases the question is the same: how much useful order can we create per joule, what materials make that possible, where does the waste heat go, and who is responsible for closing the loop when the hardware ages out?

Orbital data centers may one day make sense for particular AI inference, Earth observation, autonomy, and maybe specialised training workloads. But they will only be serious if they are designed as thermodynamic systems: power, compute, radiators, shielding, networking, servicing, debris removal, and silicon loops all in one ecosystem.

The Earth is in space too, and radiation is the only way the planet pays its final cooling bill.

Wednesday, July 22, 2026

Finding the Edge in Japan

Tsukiji Market smells like grilled seafood, wet stone, soy, tourists and logistics. Somewhere between the fish stalls and the slow current of people carrying breakfast on sticks, I walked into a knife shop and found a wall of edges pretending to be a retail display.

The commitment was not subtle. Rows of Santoku knives sat behind glass with the calm seriousness of lab instruments. Not the Don Quijote souvenir version, but the shops where the object is expected to do work for decades if you respect it. Around USD 250 felt like the going entry point for a decent Santoku in the places we wandered into, and it rose very quickly from there.

Then in Kyoto, the scale changed. A sword shop had a katana listed at 7 million yen. At that price you are no longer buying a long sharp object. You are buying metallurgy, lineage, polishing, paperwork, scarcity, and a whole cultural machine for deciding that a particular edge has survived long enough to deserve reverence.

Knives in Tsukiji Market

We visited two knife shops in Tsukiji, a sword shop in Kyoto, and another knife shop near the Pokemon Center in the Takashimaya building in Shibuya. The geography helped the idea settle. Tsukiji had the working-market feeling, knives as seafood infrastructure. Kyoto carried the ceremonial weight of blades as history. Shibuya had the polished department-store version, still serious, but now sitting in the same urban stack as Pokemon, fashion, food halls and escalators.

Japan does this particularly well: the ordinary tool is allowed to become obsessive without becoming kitsch. A kitchen knife can remain a kitchen knife while also being a small thesis on steel, heat treatment, hand skill, regional specialisation, and daily maintenance.

Sharpening as Culture

The part that caught me most was the sharpening. The edge is the temporary part of the knife. It is the part you create, lose, recreate, neglect, rescue and eventually learn to feel before you can see it. A beautiful blade with a dull edge is mostly theatre. A modest blade with a good edge is useful.

That is a very Japanese thing to make visible in a shop: the maintenance is not a sad afterthought after the purchase. It is the point. Stones, angles, pressure, slurry, patience. The object keeps working because someone returns to the boundary between metal and material and restores it.

The one time I got into trouble in Japan, amidst mostly friendly people, was in Tsukiji when I accidentally bumped someone sharpening a knife. There are mistakes that can be fixed with a smile, and there are mistakes where the animal part of your brain notices the blade first. I walked backwards slowly, muttering “gomen” with every available ounce of tourist sincerity.

Santoku knives behind glass

There is a pleasing physics to this. Cutting is not brute force. Cutting is pressure concentrated along a thin enough line that the material gives up locally. The wedge finds a gap, opens it, and moves through. When the edge rolls or blunts, the same hand and the same steel suddenly need more force, more damage, more mess.

That is where the metaphor starts doing actual work instead of sitting on the mantelpiece.

Sharp Words, Sharp Tools

We use knife language everywhere when we talk about thought. Smart people are sharp. Arguments have an edge. Teams lose their edge. We sharpen our axe when we build up skills before attacking the next task. We cut scope. We carve out time. We slice a problem into pieces. We decompose something hard into smaller pieces so the first incision becomes possible.

Doing new things often feels like pushing a blade into something that does not yet have a natural opening. You do not smash the whole surface. You look for the gap. You test the grain. You find the weak plane, the softer layer, the place where a small movement changes the geometry of the rest of the problem.

Software architecture has this hidden inside it. Debugging has it even more. A failing build, a strange sensor trace, a dataset that refuses to behave: none of these usually yield to force. You find the narrowest question that can split the problem. Does the voltage sag under load? Does the request fail before authentication or after it? Does the geospatial reprojection break before tiling or during the write path? A good diagnostic question is a sharp tool.

The wrong question is a dull knife. It still consumes effort, but mostly by bruising the work.

The Robot With an Old Edge

Then, at the space forum, I met Abhay, who has been working with a 1980s knife-sharpening robot.

That sentence felt like Japan had followed me home with a punchline.

The theme was suddenly not just knives as craft objects, but knives as an interface between craft and automation. A sharpening robot from the 1980s is old enough to predate most of our current robotics hype cycles, old enough to belong to the world of industrial control cabinets, teach pendants, custom jigs, limit switches, and stubborn mechanical repeatability. It has to keep the angle, pressure and abrasive contact honest while the steel pushes back.

Sword display in Kyoto

That is the useful tension. Sharpening looks simple until you try to automate it. The robot has to hold an angle, manage pressure, follow a changing profile, deal with abrasive wear, heat, burr formation and the awkward fact that every blade has a history. The edge is not a CAD line. It is a lived boundary on a piece of steel. The exact usage of the knife accumulates and determines its fate, reality is a stochastic process.

This is why robotics remains humbling. The easy demo is motion. The hard part is contact. Once a robot touches the world, the world starts negotiating back. Knives make that negotiation visible because the result is brutally honest. The knife is either sharp, or it is not. The tomato knows, as does the audience watching a Unitree humanoid lose the dance floor, or the Qualcomm Dragonwing IQ10 robotics platform show up in an ET NOW clip of a mid-presentation collapse.

Tools That Teach Hands

There is a lazy version of automation where machines replace skill, and a better version where machines expose what skill actually contains. A knife-sharpening robot is interesting because it cannot escape the craft problem. It has to encode something a human sharpener may feel through wrist, sound, drag and accumulated failure.

That makes it a useful object to think with. Japan’s knife shops showed the cultural end of the spectrum: reverence for the edge, the maker, the steel and the ritual of maintenance. Abhay’s robot showed the industrial end: repeatability, fixtures, kinematics, control loops and the stubborn desire to mechanise a subtle hand skill.

Between those two ends sits most serious engineering.

We do not build new things by being generally clever. We build them by maintaining edges. The edge of a discipline. The edge of a toolchain. The edge of a team that still remembers how the machinery works beneath the interface. The edge of a question sharp enough to enter a hard problem without shattering it.

The holiday version of Japan gave me knives behind glass, stones on counters, a 7 million yen katana, and Santoku knives priced like serious instruments rather than kitchen accessories. The space-forum version gave me a 1980s robot still trying to make an edge repeatable.

That is the thought I wanted to keep: sharpening is not preparation for the work.

Sharpening is part of the work.

Thursday, June 25, 2026

EO Platforms, Science Platforms, and the Apartment Between Binder and Earth Engine

When you think of running code in the browser, you probably think of Binder or Google Colab. If you are at an AWS house, you think of Sagemaker.

That is the visible end of the digital science platform story: a notebook appears in a tab, Python imports something, a chart lands on the screen, and for a moment the whole research infrastructure problem looks solved. If you are fan of a different paradigm, Python can be replaced with R, or a programming language replaced by a chat session which has its side effects as Science/Engineering plans and some code.

Then the real workflow arrives. The data is 100 TB of imagery from a High-Altitude Balloon and it is sitting at the HPC; you will have to wait in the queue for the job to submit, but the proposal deadline is tomorrow and you really need preliminary exploration graphics to illustrate your story, since humans are inherently visual creatures. Do you fake it till you make it using Nano Banana, or do you commit to a fraction of the actual work you are applying for the funding to do in full?

The HPC credentials are institutional. The analysis needs Dask workers near cloud object storage. It will take two hours for Globus to haul the data over to the nearest AWS Region. The output, when the grant is completed, should become a tile service, a STAC collection, a policy brief, a model run, and a thing someone can repeat six months later when the next sensor collection lands after that much needed CMOS and Lens upgrade. For now you really need that plot showing how a thermal mosaic align with the visible spectrum satellite imagery.

At that point the browser notebook is the doorway, not the platform. The doorway opens onto a howling void of needs and unfilled expectations.

The apartment, the hotel room, and the empty block

The continuum feels a bit like the Django versus Flask argument, except measured in satellite scenes, climate arrays, grant budgets, and institutional risk. If you don’t know what Django or Flask is, perhaps opinionated vs minimalistic are more understandable.

A managed science namespace is the Flask or FastAPI option. You get a well-tested core, working access controls, shared storage, a scheduler, a route to scalable compute, and enough freedom to design your own universe. It is like buying an empty apartment in a good part of town. The walls are sound. The plumbing works. The rooms are yours, you will not get robbed if you step outside.

A highly managed platform is closer to a hotel room at the Ritz. Everything is convenient, polished, and serviced. You get a desk, a bed, a view, and a button to press when something breaks. You probably cannot knock down a wall.

Then there is the empty block of land: Kubernetes, object storage, IAM, container registries, workflow engines, data catalogs, and a team with enough scars to make them all behave. Maximum control, maximum blast radius.

The interesting work sits between those extremes. Digital science platforms are not one product category. They are a gradient of convenience, control, reproducibility, and institutional memory.

The first split: interactive science versus production exploitation

Earth observation platforms and broader science platforms grew from different pressures.

Science platforms usually start with researchers. They need notebooks, environments, collaboration spaces, package installation, teaching material, shared compute, and a path from experiment to publication. The center of gravity is interactive work: Jupyter, RStudio, Dask, documentation, executable papers, and a community that can teach the next person how to reproduce the result.

EO exploitation platforms usually start with data gravity. They need catalogs, tiling, pixel access, area-of-interest filtering, atmospheric correction, process graphs, long-running jobs, and application packaging. The center of gravity is operational work: find the scenes, run the process near the archive, publish the output, and make the result portable across platforms.

In practice those two worlds are merging. The Pangeo stack wants cloud-native scientific computing. EOEPCA wants interoperable EO exploitation building blocks. Digital Earth platforms want curated national-scale data cubes. NASA-style platforms such as MAAP and VEDA want science teams to move from discovery to analysis to communication without rebuilding the pipes each time.

Choosing a winner is not the problem. Knowing which layer you are buying is.

A rough map of the ecosystem

The ecosystem makes more sense sorted by the job each platform does rather than by brand.

Layer Main job Examples What you gain What you give up
Ephemeral notebooks Launch a runnable environment from code Binder, repo2docker-backed demos Low friction, great teaching surface Weak persistence, weak governance, limited scale
Hosted notebooks Put compute in a managed browser workspace Google Colab, Kaggle notebooks, SageMaker Studio Lab-style services Fast start, familiar interface, low admin load Runtime limits, cloudy provenance, platform-specific behavior
Community hubs Give a research community a managed shared workspace 2i2c hubs, JupyterHub deployments, Pangeo hubs Shared identity, shared environments, scalable Dask, community ownership Still needs platform stewardship and cost discipline
Open science practice layers Teach teams how to work reproducibly OpenScapes, Project Pythia, Jupyter Book, MyST Social machinery for reproducible science Not a compute platform by itself
Cloud-native geoscience stacks Make large arrays workable near object storage Pangeo, Xarray, Dask, Zarr, Kerchunk, Intake Open, composable scientific computing You assemble and operate the stack
Data cube and EO libraries Organize analysis-ready EO collections Open Data Cube, xcube, stackstac, odc-stac EO-shaped data abstractions Needs catalog, storage, and operations around it
Managed planetary platforms Bring data catalog and compute together Google Earth Engine, Microsoft Planetary Computer Convenient data proximity and APIs Platform dependence and varying escape hatches
Standards-based EO exploitation Package processing for portability openEO, OGC API - Processes, EOEPCA, CWL-style application packages Repeatable jobs across back ends More ceremony and specification work
Science mission platforms Align infrastructure to a mission community NASA MAAP, NASA VEDA, AquaWatch, ESA EarthCODE-style efforts Domain-specific data, workflows, and communication Mission boundaries shape what is easy
Institutional digital earths Curate national or sectoral data products Digital Earth Australia, Africa, Pacific, and related platforms Trusted local data products, policy relevance Sustained funding and data governance required

That table is too tidy, of course. Real platforms straddle rows. A Pangeo hub can be a community hub, a cloud-native geoscience stack, and the working surface for a Digital Earth program. Earth Engine is both a managed planetary platform and a workflow language. EOEPCA is both architecture and open-source building blocks. A Digital Earth platform can host notebooks, APIs, dashboards, STAC catalogs, and products built from Open Data Cube.

The taxonomy still helps because “we need a science platform” can mean a teaching hub, a production EO processing system, a mission workbench, a public communication portal, or a Kubernetes tenancy model for research groups. Those are different purchases.

Pangeo is a community before it is a stack

Pangeo is often described through its software: Xarray for labelled N-dimensional arrays, Dask for parallel compute, Zarr for chunked cloud-friendly storage, Jupyter for interactive work, Kerchunk for virtualizing old file formats, Intake for catalogs, hvPlot for quick visualization, XPublish for serving datasets, and newer bounded-memory or serverless experiments such as Cubed and Xarray-Beam.

What goes into the requirements / constraints file of a notebooks repo is all and good, but like all code its value really depends on the people who read it and run it, Anne Frank’s diary is no good, if it is never found and read. The written word of any form be is a notebook or a painful diary, reaches its true potential when it transmits the ideas contained there in to the minds of thousands of others. Pangeo describes itself as a community for open, reproducible, scalable geoscience. Project Pythia is its education working group and a training hub for the geoscientific Python community. The infrastructure, documentation, showcase talks, working groups, cookbooks, and foundation tutorials are part of the platform. Project Pythia can be found, it has a lot of words, but no concrete infrastructure to run on, no printing press to replicate the proposed patterns and keep publishing them across planning cycles.

Many institutional platform programs miss this. You can install JupyterHub and Dask Gateway in a week. You cannot apt install a culture of reproducible workflows, documented environments, data access patterns, and examples that match the local science questions.

2i2c and OpenScapes occupy this gap. 2i2c turns the hub into managed open infrastructure with access control, custom environments, scalable compute, and a “Right to Replicate” philosophy, which is a useful antidote to the managed-service trap. OpenScapes works on the human operating system: habits, onboarding, documentation, and shared practice. The difference shows up when one champion leaves and the platform either survives or becomes a quiet monthly cloud bill, that everyone questions every quarter and decides to shutdown in a much “killed by Google” fashion. It have shut down a service or two in my time as well.

Earth Engine is the polished hotel room

Google Earth Engine remains the reference point for convenient planetary-scale EO analysis. It combines a multi-petabyte public catalog, server-side geospatial computation, JavaScript and Python APIs, and a browser code editor that made remote sensing feel weirdly immediate.

The trade-off is the same one that makes it attractive. You get the hotel room. You do not own the building.

For many users that is exactly right. If the job is land-cover change detection, trend mapping, rapid prototyping, teaching, or humanitarian analysis, Earth Engine collapses a brutal infrastructure problem into an API, and it has unlocked a large amount of science and public-interest work.

A national agency or regulated enterprise eventually asks harder questions. Can we run this against restricted internal data? Can we reproduce the process outside the platform? Can the cost model survive operational use? Can the workflow be audited? Can the output become an internal service rather than a script in someone else’s editor? What if Google does not like the economics and GEE gets “Killed by Google” ?

Those questions mark the boundary between convenience and control.

Planetary Computer, STAC, and the cloud-native middle

Microsoft Planetary Computer pushed a different shape: open catalogs, STAC metadata, cloud-hosted environmental datasets, Hub-style analysis environments, and APIs that fit the broader Python geospatial ecosystem. It did not only put data in the cloud; it made the catalog and assets legible to ordinary tools.

That middle ground is where STAC, Cloud Optimized GeoTIFF, Zarr, GeoParquet, and object storage conventions earn their keep. STAC calls itself a common language for geospatial information, with a core JSON structure for describing and cataloguing spatiotemporal assets. That sounds dull until you have inherited five satellite archives, three naming conventions, and one research assistant who left for a postdoc in Bremen.

These are the unglamorous freight standards of cloud-native geospatial work. Once data is published in these shapes, platforms compete on experience and operations instead of trapping users at the file boundary.

The same applies inside Digital Earth programs. Open Data Cube, odc-stac, xcube, stackstac, and Pangeo tooling become more powerful when the data model is boring and inspectable. Boring is good. Boring is how a wet-season flood product, a crop monitoring workflow, and a methane detection experiment can reuse the same infrastructure without pretending they are the same science.

openEO and EOEPCA are the uncomfortable middle

At the other end from free-form notebooks are workflow and process standards.

openEO gives users a unified API for Earth observation cloud back ends. It is a process graph world: define operations, submit work, let the back end execute near the data, and avoid rewriting the same analysis for every platform. In 2026 openEO became an OGC Community Standard, which is a useful signal that the idea has moved beyond a single project vocabulary.

OGC API - Processes handles a related need: wrap computational tasks as executable processes that a server can offer through a JSON-over-HTTP Web API. It is the unromantic contract that lets processing become a service instead of a notebook cell someone has to rerun by memory.

EOEPCA then packages a broader exploitation platform architecture around this world: reusable building blocks, open standards, federation between EO cloud platforms, application packaging, identity, data access, processing, and publication. Its mission is practical: enhance interoperability between cloud-based EO platforms and unify the fragmented cloud ecosystem for ground segment, EO science, R&D, and applications.

This middle is uncomfortable because it asks scientists to describe workflows with more ceremony than a notebook while asking infrastructure teams to expose more flexibility than a fixed portal. That ceremony earns its keep only when portability, audit, repeatability, and multi-platform execution are real requirements.

MAAP, VEDA, and AquaWatch show mission-shaped patterns

NASA’s Multi-Mission Algorithm and Analysis Platform (MAAP), Visualization, Exploration, and Data Analysis (VEDA), and AquaWatch point at another category: mission-shaped science platforms.

MAAP is built around collaborative algorithm development and analysis for biomass, carbon, and related mission data. It combines data, algorithms, and cloud computation for Earth science work at scale, including GEDI, ICESat-2, BIOMASS, NISAR, and related mission products. Its centre is not a generic notebook. It is a community of practice around specific data products, algorithms, and validation work.

VEDA is more communication and exploration oriented: science data, dashboards, stories, APIs, and applications that help users move from dataset to visible public insight. Its public dashboard talks about cloud-enabled analysis without writing code or downloading data, plus stories for science communication. In the geospatial agent stack draft I have been calling this the presentation and evidence layer: not just compute, but a way to package outputs for humans without losing provenance.

AquaWatch is the mission model closer to my own recent work: water quality intelligence rather than a generic EO workbench. Its platform shape is dictated by the problem. Satellite products, in-situ observations, calibration and validation workflows, data services, state-government users, and operational water decisions all have to sit in one fabric. Nobody wants an elegant notebook if the harmful algal bloom window has already closed and the river manager is still waiting for a plot.

Mission platforms should not be embarrassed by their specificity. A platform that knows its science domain can make strong defaults: data already mounted, examples already relevant, units already sensible, common plots already nearby, and metadata that matches the decisions people actually make.

Digital Earth platforms are institutional memory

Digital Earth platforms are a cousin of science platforms, but with more institutional weight.

Digital Earth Australia, Digital Earth Africa, Digital Earth Pacific, and related efforts are not merely places to run notebooks. They are long-running data product factories, national or regional knowledge systems, and trust infrastructure. They turn raw satellite archives into analysis-ready data and derived products that policy, environment, agriculture, water, and disaster teams can use.

The local flavours carry the point. Digital Earth Australia talks about trusted imagery and freely available analysis-ready datasets for researchers, land managers, agriculture, and emergency management. Digital Earth Africa frames the work as decision-ready products for sustainable growth across social, environmental, and economic challenges. Digital Earth Pacific is explicitly about decision-making for Pacific peoples at EO scale, with regional products, dashboards, an analytical hub, data, community, and governance in the same frame. This is not just a different skin on the same JupyterHub.

If you need a global flavour you can check out EASI from CSIRO under the AquaWatch program delivery, it flips the regional data cube approach to provide a global datacube from STAC using cloud native primitives. Almost a build your own Google Earth Engine approach, with associated DevOps and Platform Engineering burdens which you have to pay for to get.

That is a different job from a research notebook service. The value is not that one scientist can compute something, but that many people can rely on the same corrected, versioned, documented product line. Open Data Cube sits under many of these programs as an open-source way to manage analysis-ready data and has been used for continental-scale products such as Australian land-cover mapping from decades of Landsat imagery.

Here the apartment analogy changes. A Digital Earth platform is not an apartment you furnish. It is an apartment building with strata rules, fire exits, a maintenance schedule, and residents who will complain if the lift stops working, and I have been a super on such apartment buildings across 3 platforms now.

What must be portable?

Most platform debates get stuck on user interface preference. Notebooks versus portals. Python versus JavaScript. Managed service versus Kubernetes. Proprietary convenience versus open stack purity. The relevant debate is around what must be portable.

If only the result is needed, a polished managed platform may be perfect. If the method must move between agencies, clouds, and missions, then STAC, openEO, OGC API - Processes, CWL-style packaging, and open data formats become non-negotiable. If the community must outlive one grant, then docs, examples, governance, and training are platform features. If restricted data is involved, then identity, audit, and network controls are part of the science platform, not enterprise up-sell (don’t get me started on the SSO premium most SaaS platforms charge).

There are at least five kinds of portability hiding inside this one word:

  1. Data portability: can assets move or be read by standard tools?
  2. Workflow portability: can the analysis run on a different back end?
  3. Environment portability: can the software stack be rebuilt?
  4. Evidence portability: can another person inspect how the result was produced?
  5. Community portability: can another team inherit the practice without oral tradition?

The best platform choice depends on which of those you actually need.

Agents make the old platform boundary fuzzier

Agentic tooling is the next complication.

Once agents can call a STAC API, resolve a place name, submit an openEO job, monitor an Argo Workflow, query a Digital Atlas, open a notebook, and draft a VEDA-style story, the visible platform recedes behind the contracts underneath it.

Portals do not disappear. The durable value moves down into services, catalogs, workflow engines, identity boundaries, and audit trails, and the UI becomes one client among many.

This is where EO and enterprise AI rhyme. A user should be able to ask a normal question:

Show me whether wet-season surface water around this catchment is outside the last ten-year range, and give me the data sources and caveats.

The system behind that question might need a gazetteer, a STAC catalog, a data cube, Dask workers, an openEO process graph, a workflow engine, a notebook artifact, and a short written summary. Calling all of that a chatbot misses the point. It is a digital science platform with a language-shaped front door.

Science Platform advantage

There is a less glamorous question hiding under the agent story: who operates and pays for the tooling and compute fabric the agents call?

If a user asks the wet-season surface-water question and an agent fans out across a slew of tools, somebody owns every link in that chain. Somebody pays for object storage requests, scheduler time, network egress, GPU or CPU minutes, model tokens, human review, and the maintenance of the small apis that make the orchestration possible.

A serious science platform needs weight propagation in both directions. Backward propagation attributes each output to the tools, datasets, people, grants, teams, and compute fabric it consumed. Forward propagation estimates what the next run will cost before the button is pressed. Without both, the presenter of the agentic tooling with customer touch point gets all the glory and gets to keep all the revenue, while the sustaining ecosystem underneath withers on the vine and the agentic tool ends up being a toy in the long run.

This is where the phrase “Science Platform advantage” starts to be useful, in the same way people talk about quantum advantage. The claim is not that a platform is clever. The claim is that a connected, orchestrated chain of task-specific tooling, assembled on demand and cost-tracked properly, delivers more value than doing the same work any other way.

For the utilitarians in the room, that claim needs a benchmark. Pose a real problem. Solve it fully the old way first: portal clicks, downloads, hand-written scripts, email threads, queue waits, manual plots, confused provenance, and the final slide dropped into a proposal at 11:47 pm. Then build the agentic way and run the same class of problem a thousand times, so the cost of building the new fabric is amortized across many analyses rather than charged to the first heroic demo.

The trouble is that no one was keeping clean accounts while we did it the old way. We rarely know how much the portal-clicking cost once staff time, failed runs, duplicate downloads, local storage, interpretation drift, and meetings are counted. So we cannot honestly promise cheaper or faster without measuring both sides. We can be more certain about the energy bill: silicon currently delivers far less useful scientific reasoning per watt than the human brain fed on caffeine and croissants.

That does not weaken the platform argument. It makes the accounting part of the platform. The useful question is not “can an agent do this?” The useful question is whether the platform can tell us what it did, who paid, who benefited, and whether the next thousand runs beat the old way by enough to justify the extra silicon. Will the environmental solution we are building preserve the environment or become yet another nail in the anthropogenic coffin we are putting around our planet.

My current bias

I lean toward the apartment model.

Give science teams a managed namespace with identity, storage, standard catalogs, scalable compute, observability, and a small number of blessed paths to production. Keep the walls movable. Let the team bring Pangeo, Open Data Cube, xcube, DuckDB, GDAL, QGIS plugins, or specialist models where the science demands it. Make the durable contracts boring: STAC, COG, Zarr, GeoParquet, openEO, OGC APIs, container images, reproducible environments, and documented workflows.

Use the hotel room when speed beats ownership. Use the empty block only when the institution is ready to become a platform operator. Everything else is a furnishing choice.

EO platforms and science platforms are not rival tribes. They are different answers to the same infrastructure question: how much freedom do you need, how much responsibility can you carry, and what parts of the science must still make sense when the browser tab is closed?

Sources and threads to pull next

Friday, May 29, 2026

We Don't Have Hooves: AI Logos, Cognitive Shedding, and the Exoskeleton Economy

I spent a weekend writing a small Rust tool that composites AI company logos onto a Redbubble full-print t-shirt canvas. Not because anyone asked. Halfway through tuning the layout I noticed something faintly absurd: every logo I was tiling looked like a tyre tread. OpenAI’s swirl is a directional rain pattern. Gemini’s four-pointed star is a Bridgestone Blizzak winter sipe. Anthropic’s ringed A is a sidewall stamp. Nvidia’s eye is a hub cap. Lay them next to each other on a 7000-pixel canvas and the whole thing reads less like an industry portrait and more like a Beaurepaires catalogue page.

Logos From Loops

The visual grammar of AI companies has converged on a small family of forms: radial symmetry, interlocking arcs, gradients from cool to warm, the occasional offset chevron. They are tread patterns. They are tread patterns because tread patterns are what you draw when you want to suggest motion, grip, and continuous contact with a surface you are moving over – which is exactly the brand promise of a model that turns prompts into outputs without you needing to know how the road underneath works.

The tool generates 21 of these tread-pattern logos – the leaders, challengers, niche players, and visionaries from the April 2026 Gartner Magic Quadrant for Enterprise AI Coding Agents, plus the dozen companies tracked by isaiprofitable.com – and tiles them across the canvas under four layouts: a jittered grid, a hex pack, an arabesque mask built from Lissajous curves under a wallpaper symmetry group, and a Voronoi packer that wraps cleanly at the edges. The arabesque mode is the one that looks most like a real design, which is fitting because the brand identities themselves are arabesques of the same underlying motif.

Nothing in the code is novel. What is striking is how little code it takes to produce something that passes for a branding agency deliverable. Spend a few minutes tweaking curve density and symmetry group and you can cover most of the Fortune 500’s recent AI rebrand portfolio without engaging a designer. None of it requires aesthetic judgement. All of it requires a loop.

That is worth sitting with before moving on to the money.

The Gartner Thermometer and the Sequoia Deficit

The 2024 and 2025 Gartner Hype Cycles placed generative AI at or near the Peak of Inflated Expectations, the top of the curve before the long slide into the Trough of Disillusionment. That topological framing is rough but useful. More arresting is the arithmetic underneath it.

Sequoia Capital published a piece in mid-2024 estimating that AI infrastructure – primarily Nvidia GPU clusters – required roughly $600 billion in annual revenue to justify the capital being committed, while observable AI-attributable revenue across the industry was a fraction of that figure. The gap has a name in finance: “productive deployment lag.” In plain language: the shovels are being sold, the mines are being dug, and the gold has not appeared at the rate the tunnel length implies it should. On isaiprofitable.com, the only company with a green checkmark next to its name is Nvidia, the one selling the shovels.

The 21-tread-pattern t-shirt is a small monument to this gap. Nvidia at the hub, eleven others on the sidewall burning through capital at rates that make the GPU revenue arithmetic interesting, one wallpaper symmetry group holding them all together on a cotton substrate.

The more interesting question is not whether AI is profitable yet. It is why AI is already affecting how we think, even before the P&L sheets catch up.

The Fur Analogy and Cognitive Shedding

Around 1.5 million years ago, Homo erectus started losing body hair. The proximate cause was almost certainly thermoregulation: an upright, running hunter on the African savannah generates core heat faster than a fur coat can dissipate it under midday sun. So the fur went. But heat still needed managing. The solution was clothing, an external thermal regulation artifact that did the job the body had previously handled internally.

This is a pattern that runs through the entire history of human technology. We replace innate biological functions with external artifacts. We then build manufacturing chains around those artifacts. We build economic systems around those chains. The original biological capacity atrophies from disuse or is simply never developed in the first place, because the artifact is already there when the individual arrives.

We do not have hooves. We have shoes. We do not have gills. We have submarines. We do not have the magnetoreceptors that birds use on migration routes. We have GPS. In each case the external artifact is not merely a substitute; it is a platform. It invites elaboration. The shoe becomes the boot, the boot becomes the orthotic, the orthotic becomes a running shoe industry, and the running shoe industry eventually funds the biomechanics research that feeds back into the next generation of the artifact.

I spent six months in late 2022 and early 2023 as an Enterprise Architect contractor at Bridgestone Australia in Adelaide, wiring up the interfaces between SAP, Salesforce, and the mobile mechanic booking platforms that schedule a van to a customer’s driveway to swap a set of tyres. The work was unglamorous integration plumbing – canonical data models, idempotent message contracts, the usual distributed-systems hygiene – but it gave me a tourist’s window into how a tyre and car parts business actually operates. Every node in the system was eventually a physical thing: a passenger radial sitting on a pallet in a Wingfield warehouse, a wheel alignment slot at a Beaurepaires bay, a truck retread coming back from its second life on a B-double. The software was a thin coordination layer over a very heavy industrial substrate.

The history of the company that owns that substrate is the part that stuck with me. Bridgestone – ブリヂストン – started in 1931 not as a tyre company but as a spinoff of a 久留米 (Kurume), 九州 (Kyushu) maker of 足袋 (tabi) split-toe footwear. The founder, 石橋正二郎 (Shojiro Ishibashi), had been adding rubber soles to cotton tabi since 1923 under the Asahi brand, and rubber soles turned out to be the gateway material to rubber tyres. The name Bridgestone is a literal English inversion of his surname: 石 (ishi, stone) and 橋 (hashi, bridge), reversed and translated, picked partly because it sounded export-ready and partly to echo Firestone, the American tyre company he admired. (Bridgestone would eventually acquire Firestone in 1988 for $2.6 billion, which is the kind of historical loop that only happens in long-lived industrial companies.) The katakana spelling ブリヂストン preserves an archaic ヂ where modern Japanese would write ジ, a piece of pre-war orthography the brand keeps the way Mitsubishi keeps its three diamonds.

What I took away from those six months is that Bridgestone is not really a tyre conglomerate that used to make shoes. It is a rubber compounding and supply-chain organisation that noticed rubber was useful for several different external human exoskeletons – first feet, then cars, then conveyor belts, hoses, seismic isolators under buildings, and now sustainably-sourced guayule and dandelion-derived natural rubber to hedge against Hevea brasiliensis geopolitics. The material is the through-line. The product is whichever exoskeleton the century happens to need.

I always jokingly refer to BridgeStone as - “Big Rubber”.

The Car Was Always an Exoskeleton

The automotive vocabulary has colonised AI discourse so completely it has become invisible. We “steer” language models. We apply “guardrails.” We talk about “autopilot” and “co-pilot” and “lanes” and “on-ramps.” There is a vehicle for sale right now whose entire value proposition is that the steering wheel becomes optional once the AI is mature enough. Almost nobody stops to ask why this particular metaphor landed so naturally.

Here is one answer: cars and AI are both exoskeletons.

A car is not a vehicle in the narrow sense. It is a kinetic exoskeleton that extends the range, speed, load-bearing capacity, and weather tolerance of a soft-bodied primate who would otherwise top out at 5 km/h on a good day. The car does not move instead of the human; it extends the human’s movement by several orders of magnitude at the cost of an elaborate support infrastructure: roads, fuel networks, insurance markets, traffic law, emissions regulation, and, yes, tyre companies.

AI is doing the same thing to cognition. The language model does not think instead of the human; it extends the human’s language-generation and pattern-retrieval capacity by several orders of magnitude at the cost of an equally elaborate support infrastructure: GPU clusters, training pipelines, safety teams, regulatory frameworks, and eventually a Gartner hype cycle or two. The car vocabulary arrived so naturally because the thing being described was already familiar. We built the kinetic exoskeleton first. The cognitive one came later, but the shape of the dependency relationship – human plus artifact plus infrastructure – is identical.

What Gets Shed

The cognitive functions most visibly affected are the ones that involve generation under uncertainty: drafting a first sentence, naming a variable, composing an email, sketching a logo. These are precisely the tasks that feel slow and effortful without assistance, and precisely the tasks that AI handles smoothly. The friction is real. The assistance is real. The atrophy risk is also real.

Musicians who practise scales develop neural pathways that do not form if the scales are skipped. Writers who struggle through first drafts develop a tolerance for ambiguity that does not develop if a model always resolves it for them. The logos from the code above look entirely plausible. They look like every other AI logo in the current design vocabulary. They were generated without any cognitive friction whatsoever, which is both the point and the problem. The friction was where the design decision lived.

This does not mean AI assistance is bad, any more than wearing shoes is bad. It means the physiotherapy question matters: are you also doing the cognitive equivalent of the exercises that keep the underlying capacity from going the way of the body hair or your quads since you have spent 2 days chasing the zebra you speared and are waiting to run out of steam and die.

The Shoe Company Principle

Ishibashi’s insight in 1931 was not that feet needed covering; the Asahi tabi side of the business already had that locked up. His insight was that rubber was a platform material for exoskeletal extension, and that the same compounding science, vulcanisation know-how, and distribution muscle that made a good rubber-soled tabi could make a good passenger tyre. He followed the material from one form of human locomotion extension to the next, and a hundred years later that bet is still paying out across tyres, conveyor belts, and seismic isolators.

The AI companies following the GPU stack from language generation to reasoning to planning to embodied robotics are doing exactly this. The H100 is the rubber: a platform material whose applications are not exhausted by the first product built on it. The chat interfaces, the co-pilots, the logo generators – these are the 足袋. What comes next on that manufacturing chain – the 自動車 (jidousha, automobile) tyre equivalent for cognition – is the part worth watching, and worth surviving the trough of disillusionment for.

Whether the current crop of AI businesses is profitable by the time the next Gartner report drops is the wrong question. Whether the infrastructure being built can outlast the hype cycle long enough to produce the genuine platform shift is the question Ishibashi would have asked, probably while measuring rubber tensile strength in a factory that used to make footwear. Japanese has a phrase for that patient industrial cultivation: 改善 (kaizen, continuous improvement). It is not the same word as ハイプ (haipu, hype), and the two have rarely been observed in the same building.

The last shoe company that asked the wrong question about its own product is still making pneumatic rubber cylinders for the machines that replaced the horses we no longer needed to breed. Every AI logo on the t-shirt is a tread pattern drawn by people who do not yet know which century of exoskeleton they are designing for. That beats a PowerPoint ecosystem built around the profitability question, and it is the bet I would rather be inside of when the trough arrives.


The code is at ai_logos_shirt – a small Rust crate, MIT licensed, build instructions in the README. Ping me if you have strong opinions about cognitive atrophy, the Sequoia revenue gap, or split-toe rubber footwear.

Saturday, May 23, 2026

From Digital Atlas to Gazet: Building a Geospatial Agent Stack for Enterprise AI

The same thought keeps coming back whenever I look at geospatial AI: too much useful work is still trapped in slow, manual interfaces.

Someone opens a portal, clicks through search forms, downloads files, copies a bounding box, jumps to a geocoder, then checks an internal approvals tool. None of this is mysterious; it is just fragmented.

That is why MCP matters here. Not because every problem needs another chatbot, but because a composed agent stack can turn UI choreography into a question, a traceable tool chain, and a defensible answer.

The shape of that stack is getting clearer:

  1. A discovery layer for authoritative datasets and services.
  2. A place-resolution layer for turning ambiguous human geography into valid geometry.
  3. A retrieval and processing layer for actual data operations.
  4. A governance layer so this can survive contact with enterprise reality.
  5. An orchestration layer that routes work to the right model and the right tool at the right time.

Themes carried from the earlier LinkedIn post

The LinkedIn thread that led to this draft had four recurring ideas, and they still hold:

  1. Most geospatial AI pain is not in model quality. It is in UI choreography.
  2. Narrow components with explicit contracts beat one giant, vague “do-everything” agent.
  3. Portals are temporary. Durable value sits in services, workflows, and evidence trails.
  4. The end state is not one-shot answers. It is persistent monitoring plus governed recomputation.

This post extends those ideas with concrete stack boundaries, standards, and orchestration patterns.

Digital Atlas of Australia as the discovery layer

In daa_mcp, I wrapped the Digital Atlas of Australia search API as a Go MCP server. The target is the Digital Atlas endpoint at https://digital.atlas.gov.au/api/search/v1, with a very narrow tool surface:

  • atlas_list_collections
  • atlas_search_items
  • atlas_answer_query

That narrowness is deliberate. Discovery tools should be boring, explicit, and provenance-heavy. If an agent cannot reliably name the dataset, map, or document it found, and where it came from, it should not improvise higher-order spatial reasoning.

This is the first important pattern for enterprise AI engineering: do not ask the model to remember the catalog. Ask the catalog.

In practice, a user should be able to ask “what hazard datasets are relevant around this place?” and get source URLs, approximate bounds, and the inventory used to produce the answer. That alone is a major improvement over portal-clicking.

DevSeed’s Gazet is the missing place-resolution layer

The more interesting development lately is not another catalog wrapper. It is the rise of narrower geospatial AI components that do one thing well.

Development Seed’s Gazet is a very good example. It is a lightweight natural-language geocoder and GIS operations system over Overture and Natural Earth parquet datasets. The point is not to sound impressive. The point is to turn a phrase like “the northern half of India” or “districts along the Ganges” into valid geometry and spatial SQL.

That matters because geospatial systems usually break before the raster math starts. They break at the human-language boundary: fuzzy place names, overlapping regions, ambiguous jurisdictions, rivers that matter politically but not administratively, borders people describe one way and datasets encode another.

DevSeed’s public write-up on Gazet is refreshing because it avoids frontier-model mysticism. They fine-tuned a Qwen 3.5 0.8B model, generated around 70k validated training pairs, and built a system that runs on CPU, packages into a single container, and emits valid geometry. The model card shows an 812 MB Q8 GGUF artifact. That is software engineering.

The surrounding design is exactly the structure geospatial AI needs:

  • fuzzy candidate search against Overture divisions and Natural Earth
  • DuckDB-backed in-memory spatial SQL
  • GeoJSON output rather than vague textual summaries
  • a path toward execution-feedback loops and CodeAct-style tool use

Gazet is not an MCP server today, but it is exactly the kind of component that should sit behind one. A Digital Atlas MCP answers “what data exists?”. A Gazet-style place tool answers “what geometry did the user mean?”. Keeping those jobs separate reduces hallucination at both layers.

Skills and MCPs are complementary, not interchangeable

Development Seed’s public skills repository reinforces the same architectural idea from another angle. Skills package workflow knowledge and output structure; MCP servers package live tool access.

That distinction matters. A skill can tell an agent how to build a VEDA story, export an issue to markdown, or set up a Python repo. An MCP server lets that same agent call live APIs, inspect datasets, or resolve fresh operational context.

Enterprise AI work needs both. One gives you procedure. The other gives you reach.

STAC, GDAL, and the rest of the operational path

Once discovery and place resolution are handled, the rest of the geospatial chain looks familiar again.

STAC remains the right interoperability layer for item and asset selection. GDAL, QGIS-style tooling, OSM connectors, Earthdata accessors, and similar MCPs remain the right place for the sharp-edged operational work: clipping, reprojection, vector joins, raster access, metadata inspection, and export.

This is why I still do not buy the idea of a single universal geospatial MCP. Real systems are layered:

Layer Job Example
Discovery Find authoritative datasets, maps, and documents daa_mcp
Place resolution Turn language into geometry Gazet-style geocoder / gazetteer
Catalog handoff Resolve items and assets STAC MCP
Workflow orchestration Schedule and monitor long-running jobs Argo Workflows via MCP
Spatial compute Transform and analyze data GDAL / QGIS / OSM style MCPs
Presentation Package outputs for humans VEDA-style skills, notebooks, apps

The protocol is the plumbing. The quality comes from giving each part of the stack a narrow responsibility.

This is the same systems lesson in geospatial form: trying to make one component do discovery, place semantics, heavy compute, and governance usually creates brittle architecture. Small explicit layers look less magical, but they survive production.

EO processing standards are now part of the same stack

This is where real operations begin. Once a question needs heavy lifting, you need a standards-aligned processing path, not just another API call.

I think of it as three aligned pieces:

  • eoAPI as the service substrate (STAC, tiles, PostGIS-adjacent query surfaces)
  • openEO UDFs for custom analysis logic that does not fit built-in processes
  • OGC API - Processes as a portable execution contract for geospatial jobs

This matters because of execution portability, not standards purity. If a workflow is represented through openEO process graphs, UDF hooks, and OGC process semantics, you are no longer trapped in one vendor UI or one internal notebook convention.

The openEO side is especially useful because it is explicit about chunked execution and long-running back-end jobs. run_udf and related process patterns (apply_dimension, apply_neighborhood, reduce_dimension) are built for data-cube scale operations where synchronous request/response is the wrong abstraction.

OGC API - Processes complements this by giving a common HTTP interface for process descriptions, inputs, execution, and result retrieval. That is the bridge between geospatial compute and enterprise service design: you can expose processing as a governed capability, not just a script somebody knows how to run.

eoAPI then provides a practical packaging layer around STAC-first infrastructure (pgSTAC, stac-fastapi, titiler-pgstac, tipg). Data discovery and data services stay first-class while compute orchestration grows around them.

Long-running analysis needs workflow orchestration, not prompt retries

When EO analysis becomes asynchronous (tiling, temporal composites, model inference over large extents, zonal stats at scale), agent architecture must move from “call tool, get answer” to “submit job, monitor, collect artifacts, summarize result”.

This is exactly where Argo Workflows patterns fit, and why Argo-flavored MCP servers are interesting. The MCP Market Argo server by jakkaj exposes workflow submission/status/result retrieval through JSON-RPC. That maps naturally to agent behavior:

  1. build a workflow payload from resolved geometry + selected assets
  2. submit to workflow engine
  3. poll status with bounded retries and timeout policy
  4. fetch outputs and register artifact locations
  5. return a grounded summary with links to outputs and provenance

Critically, outputs here are not only text. They can be Cloud Optimized GeoTIFFs, STAC Items, GeoParquet extracts, vector tiles, QA reports, or model feature embeddings. For geospatial agents, the right response class is generated artifacts plus explainable metadata, not just a paragraph.

If you combine this with gateway policy (auth, quotas, audit) and model routing, you end up with a more durable operating model:

  • language models interpret intent and coordinate tools
  • workflow systems execute expensive, long-running spatial jobs
  • standards-based APIs keep outputs portable across teams and platforms

That is much closer to “EO production system” than “chatbot with map screenshots”.

Why enterprises should care: this is really about UI replacement

The bigger opportunity is not just geospatial search. It is enterprise task conversion.

Most corporate and government knowledge work still lives in forms, portals, dashboards, policy systems, and browser tabs. Much of it is manual API orchestration done by humans through UIs.

We should be blunt about portal economics. Most are disposable visual sales tools, one level up from a PowerPoint deck. They are useful while an initiative is being socialized or funded, but once that phase passes, maintenance becomes hard to justify.

The exception is when the interface itself is the monetized product. If the UI is a booking or experience engine, like Airbnb, Uber, or Netflix, the interface is the business and ongoing investment is obvious. If it is only a discovery surface, the long-term value is usually in the underlying services and automations, not the glossy front end.

That is where agent stacks become interesting: not “replace staff with a bot”, but “replace repetitive navigation with question answering backed by orchestrated tools”.

For example:

  • use a Digital Atlas MCP to find relevant public datasets
  • use a Gazet-style tool to resolve the place phrase into geometry
  • use STAC or downstream data APIs to locate assets
  • use GDAL or analytics tools to extract what matters
  • use an internal engineering or policy system to fetch approvals, tickets, or previous decisions
  • return one answer with links, bounds, intermediate evidence, and the exact tools invoked

That is a much more defensible enterprise AI story than a generic assistant sitting on top of a screen scraper.

The enterprise layer above the tools: gateway patterns

Of course, the moment you try to productionize this, you run into the boring parts that actually matter: auth, quotas, observability, data leakage, audit, policy, and cost.

At that point, the conversation should move from product selection to gateway patterns. Martin Fowler’s gateway pattern framing is useful because it centers controlled mediation between clients and backend capabilities, which maps directly onto agent-to-tool and agent-to-service boundaries.

The first pattern is identity mediation. Agent calls need to carry a clear identity boundary between user, agent, and downstream systems, with policy checks at each boundary.

The second pattern is protocol normalization. Teams will mix chat payloads, tool calls, MCP traffic, and legacy APIs. The gateway has to normalize those flows so routing and controls are consistent.

The third pattern is cost and budget governance. Token and request spend cannot be an afterthought. Per-key, per-team, and per-tier budgets need to be enforceable in the traffic path, not in a monthly spreadsheet.

The fourth pattern is safety policy composition. Guardrails are rarely one thing. In practice you need layered controls: authentication, content moderation, prompt-injection checks, data-loss prevention, and explicit deny behavior.

The fifth pattern is telemetry with replayable evidence. A useful gateway record is not just “request succeeded”. It is who called what, with which policy version, routed to which provider or tool, at what cost, with what outcome.

I still mention Kong mainly as a signal of category maturity, not as a single implementation path. The same pattern language also shows up in Otoroshi’s AI gateway model: provider abstraction, OpenAI-compatible route surfaces, API-key enforcement, metadata-driven budgets, moderation and regex guardrails, plus extension-based control points.

Whether a team uses Kong, Otoroshi, or another gateway stack is less important than whether these patterns are explicit. Enterprises want MCPs and agent flows, but they need them behind durable control planes instead of scattered sidecars with weak visibility.

Once agents start calling internal systems, this layer becomes unavoidable. Someone will want to know who called what, with which identity, against which policy, and how many tokens or requests that answer burned to produce.

Small models are not a concession, they are often the right architecture

The other part of this conversation that is becoming more honest is model size.

Development Seed’s Gazet makes the point very clearly: many geospatial tasks are structured enough that a small model, grounded to the right schema and surrounded with the right tooling, is better engineering than throwing a giant model at the problem.

That also lines up with what NVIDIA has been highlighting around agentic workloads. Their recent MiniMax M2.7 material is not about a universal oracle; it is about efficient agentic harnesses, tool calling, and orchestration-friendly serving with explicit tool-call parsers, auto-tool-choice, and a runtime story through vLLM, SGLang, NIM, and NemoClaw.

MiniMax M2.7 is not “small” in total parameter count, but it is architected in the direction the market is moving: sparse activation, efficient serving, orchestration hooks, and infrastructure that treats tools as first-class. The important lesson is not the specific model; it is the pattern.

The pattern looks like this:

  • small or moderate specialist models where the task is structured
  • larger reasoning models only where the ambiguity genuinely demands them
  • explicit tool routing rather than one giant model pretending to be every subsystem

For geospatial and enterprise workflows, that is just common sense.

The real end state

The end state here is not “chat with your maps”.

It is something more useful:

  1. take a question expressed in normal language
  2. resolve the place semantics properly
  3. discover the authoritative data sources
  4. retrieve or compute what is needed, including expensive long-running analytics when required
  5. enforce enterprise controls on the path
  6. return an answer that is fast, inspectable, and grounded in tools

Beyond one-shot questions, run persistent agents that watch for change over time. For hazard operations, that means continuously tracking weather, flood signals, fire risk, and related event streams, then escalating when deviation from steady state crosses defined thresholds.

The same pattern applies to slower domains such as seasonal wheat growth. A persistent agent should infer baseline behavior from historical and current EO catalogs, run heavy analysis when confidence drops, and react when observed trajectories diverge from expected seasonal dynamics.

This is where long-running workflows and persistent agents work together: the workflow engine handles expensive catalog-scale computation, while the agent handles temporal monitoring, trigger logic, and action routing.

That operational loop was the key point in the earlier LinkedIn post, and it is worth repeating: in enterprise geospatial systems, value compounds when agents watch state over time and selectively escalate computation, not when they generate one more static summary.

That is what turns manual UI work into operational question answering.

For geospatial work, it means less tab-hopping and more reproducible spatial reasoning. For enterprise AI more broadly, it means agents stop being a decorative chat layer and start looking more like a disciplined API and workflow orchestration fabric.

Better than another dashboard, frankly.

If you are building in this direction, the interesting design questions are no longer “which model is smartest?” They are:

  • where should discovery stop and reasoning begin?
  • which place-resolution tasks deserve their own narrow model?
  • which tools should be exposed directly as MCPs versus hidden behind workflow skills?
  • what sits at the gateway for auth, quotas, audit, and A2A telemetry?
  • which monitoring loops should run continuously, and what deviations should trigger expensive recomputation or human escalation?

That is engineering, not theatre.

References

Wednesday, May 13, 2026

AI-assisted PCB design for energy monitoring (and scaling up don't trust the autorouter)

There is a specific smell to late-stage PCB work. A mix of coffee, solder mask anxiety, and the faint optimism that one more route pass will magically make analog behave. The poking around with oscilloscope probes and poring at datasheets to find out that you failed to pull reset low, out comes the magnet wires for a bodge.

Over the last week I have been building out an ADE9000 breakout with an AI-assisted workflow wrapped around KiCAD scripting. The results are useful, occasionally impressive, and still very far from “hands-off” for precision energy monitoring.

If you grew up with “don’t trust the autorouter” as muscle memory, good news: the saying still holds. We just scaled the blast radius from one menu click to an entire AI pipeline.

AI-aided KiCad schematic work in VS Code and KiCad

What changed on the board, not just on a slide deck

The recent commit sequence in ADE9000_Breakout tells the story better than any marketing copy:

  • d1e3352 (2026-05-07): “Initial AI Creation”
  • 043161c (2026-05-08): “Complete routing”
  • b8c8132 (2026-05-09): “Reroute with JST connector for SPI”
  • a469246 (2026-05-09): “Move decoupling closer”
  • 84b86e7 (2026-05-12): “Relayout using connectors for analog inputs”
  • 7d4b420 (2026-05-16): “Rerouted with Groundplanes and new skills”
  • c40e40a (2026-05-16): “Added License”
  • 9b2d97e (2026-05-17): “Add project-local 3D CAD assets”
  • cf8ba2c (2026-05-17): “Fix CT jack STEP orientation”
  • f5a11b2 (2026-05-17): “Remove CT jack pad overlays”

This was not a single-shot generation. It was iterative engineering with scripting and machine assistance in the loop:

  • Placement and connector mapping in scripts like place_pcb.py.
  • Deterministic route passes in route_pcb.py.
  • Critical route seeding and patching in seed_critical_routes.py and patch_remaining_routes.py.
  • Mechanical/silk cleanup with apply_board_markings.py and move_refs_to_silkscreen.py.
  • Continuous ERC/DRC artifacts (erc.json, drc.json) committed as hard checkpoints.
  • 3D STEP model handling pushed into the reusable layout and size-shape skills so mechanical review can keep pace with PCB edits.

AI-aided ADE9000 PCB layout in KiCad

That pattern matters. The AI and automation stack gave speed and repeatability, but the engineering value came from repeated correction passes driven by board physics.

The same iteration loop is now visible in whatnick-energy-monitor-skills:

  • 335a718 (2026-05-16): Initial whatnick energy monitor skills
  • 78bfc44 (2026-05-17): Document STEP model workflow
  • 79d925d (2026-05-17): Clarify connector STEP model matching
  • af57c2d (2026-05-17): Document connector CAD alignment workflow
  • 32adeff (2026-05-17): Correct ADE9000 jack CAD guidance
  • d4167f6 (2026-05-17): Remove ADE9000 jack overlay guidance

That repo now captures reusable circuit, layout, routing, and board-shape guidance, plus the ADE9000 project overlay. The 3D model side was not a first-pass success either. STEP exports and connector models took multiple iterations before the project-local paths, model matching, and export workflow were stable enough to trust in a mechanical review. The later commits are the best evidence: first add local CAD assets, then discover the CT jack STEP orientation is wrong, then remove pad overlays that made the model look plausible while hiding the fact that the footprint and mechanical story needed to line up properly.

This is where AI-assisted hardware feels different from AI-assisted code. In software, a bad abstraction usually fails in tests or production logs. In PCB work, a bad abstraction can become a connector body floating neatly above the wrong pads in the 3D viewer. It looks professional right up until the part, enclosure, or cable says otherwise.

Pivoting the ADE9000 board toward the larger analog-connector layout

NotebookLM research: good at methodology, weaker on analog edge cases

I started on this adventure with posts from Samuel Beek promoting AI PCB design. I blended in my research background and curated a set of academic papers on AI/Algorithm usage in PCB place-n-route. I queried my pre-created NotebookLM notebook “PCB Place and Route Algorithms” specifically for mixed-signal energy-monitoring constraints.

The useful part of that synthesis:

  • Current AI placement/routing research still optimizes mostly for geometric proxies (wirelength, overlap, congestion).
  • Newer approaches improve constraint capture and collaboration, but are explicitly human-in-the-loop.
  • Model quality degrades on low-frequency pattern classes and novel interface combinations (cold-start behavior).

The important caveat from the same query was even more telling: source coverage was strong on AI placement methodology, but thinner on precision metering specifics like safety creepage strategy, return-current choreography around split references, and “what actually ruins ENOB on a real board at 2am”.

That gap is exactly the point.

Schematik, SnapMagic, and the new hardware workflow stack

Samuel Beek’s Schematik story is almost too perfect as an origin myth for this moment. An AI-generated wiring guide for a home-grown door opener took out the fuses in his apartment, which is a fairly direct way for physics to reject your prompt. Schematik has since raised $4.6 million from Lightspeed Venture Partners and is positioning itself as a “Cursor for Hardware”: describe a device in plain language, get a bill of materials, purchase links, and assembly instructions.

The interesting engineering choice is the safety boundary. Schematik is deliberately aiming at low-voltage circuits, typically 3-5 V IoT and maker projects, because that is where the promise is large and the downside can still be bounded. That is a sensible line. It is also a reminder that “AI for hardware” is not one market. The assistant that helps someone build an MP3 player is not the same system I would trust near mains metering, isolated sensing, or a DIN rail enclosure without a lot more constraint machinery around it.

SnapMagic is attacking a nearby but different layer of the stack. Its pitch is an AI copilot for electronics design, built on the huge CAD model base that started as SnapEDA: symbols, footprints, 3D models, part discovery, BOM optimization, supply-chain substitution, and integration with existing EDA tools including KiCad. That matters because a surprising amount of PCB time is not heroic analog insight; it is finding the right model, importing it cleanly, checking whether the footprint is sane, and making sure the thing still exists at Mouser or Digi-Key.

Schematik is closer to natural-language project generation. SnapMagic is closer to CAD-data and component-selection acceleration. My little ADE9000 workflow sits in the garage between them: NotebookLM for research synthesis, KiCad Python for deterministic changes, Freerouting for a first pass, project-local skills for repeatable domain knowledge, and human review for the parts that still smell like physics.

That is the practical opening for individual designers. You do not need to wait for one perfect vendor platform. You can build a small, opinionated workflow from pieces you already control:

  1. Put your design rules and recurring board-family choices into a local skill or checklist.
  2. Use AI for datasheet digestion, net naming, script generation, and alternative exploration.
  3. Keep KiCad, ERC, DRC, STEP export, and git history as the accountability layer.
  4. Treat external libraries like SnapMagic/SnapEDA as accelerators, then verify footprints, symbols, pin numbers, and 3D models against datasheets and mechanical reality.
  5. Let autorouters and AI propose routes, but hand-check return currents, decoupling loops, creepage, clocks, testability, and enclosure fit.

That sounds less magical than “hardware Cursor”, but it is much closer to how individual designers can safely get leverage today.

Why this hurts more on energy monitoring boards

An ADE9000-style board is not just “digital plus some analog”. It is a negotiated peace treaty between:

  • tiny differential analog signals,
  • noisy clocks and digital SPI edges,
  • shared ground structures,
  • high-voltage interfacing constraints,
  • and assembly realities.

AI can route what it can score. Physics punishes what you forgot to score.

For energy monitoring, the failure modes are often subtle first and expensive later:

  • A seemingly short route with a terrible return path becomes an EMI antenna.
  • “Close enough” decoupling in XY turns into high loop inductance in 3D.
  • Digital fanout convenience leaks noise into the measurement front end.
  • Clearance passes in one view while creepage silently fails along real surfaces.

The scaled-up autorouter adage

Classic autorouter distrust was about ugly traces and cleanup effort.

AI-assisted distrust is about false confidence.

You now get cleaner visuals, plausible routing, and confidence scores. The board can look more “engineered” while still violating analog intent. That is worse than obviously bad output, because it delays the moment when a human gets suspicious.

In the ADE9000_Breakout commits, that showed up as repeated topology and placement adjustments:

  • decoupling moved closer,
  • connector strategy revised,
  • critical nets explicitly seeded,
  • remaining logical gaps patched after freeroute import,
  • then relayout for analog input connector realism.

ADE9000 input clamp and analog connector pivot

None of that is anti-AI. It is pro-accountability.

A practical review checklist I now treat as mandatory

Before I trust an AI-assisted pass on a precision board, I manually review:

  1. Return current continuity under each critical signal path.
  2. Analog/digital ground interaction at the exact stitch points, not just net names.
  3. Decoupling loop geometry (pin, cap, via topology), not just nearest-component distance.
  4. Clock and fast digital net proximity to high-impedance analog channels.
  5. Creepage and clearance across real isolation boundaries and along surfaces.
  6. Testpoint access and assembly risks (reworkability, tombstoning, awkward probe points).

If any of those rely on “the model probably understood that”, I assume it did not.

What AI is genuinely good for in this workflow

After using it in anger, the wins are real:

  • Faster exploration of placement variants.
  • Deterministic scriptable edits to keep design intent reproducible.
  • Constraint management that catches obvious misses early.
  • Better ergonomics for repeated board evolutions.
  • Mechanical and export workflows, including STEP models, can be standardized, but they still need several passes to reconcile footprint libraries, connector variants, and CAD export paths.

This is similar to CNC in machining. You still need a machinist mindset. You just get to fail faster and with better logs.

The part that still needs engineers

The physics does not care whether a trace came from a human, an RL policy, or a nicely branded copilot.

Energy metering boards live or die on the details that are hardest to encode as generic reward functions. The edge where analog integrity, EMC, and safety overlap is still mostly tacit knowledge earned through measurements, bring-up scars, and post-mortems.

So yes, use AI aggressively for PCB work. I certainly am.

Just keep the old sign above the bench.

Don’t trust the autorouter.

Now it applies to systems, not just traces.

If you are building similar mixed-signal boards, I would love to compare review checklists and failure cases that escaped DRC but showed up on the bench.