Azure rents HF at $8/hr, SkyPilot zeros egress, sqlite-utils 4.0 skips rollback

TL;DR

Azure Foundry rents Hugging Face models at ~$8/hr H100, above Fireworks and Together on the specialist PaaS market.
SkyPilot mounts HF buckets with $0 egress, re-uploading 8.43 GB in 8 seconds via Xet chunking.
sqlite-utils 4.0 folds migrations into core and ships without rollback on a fix-forward philosophy.
Hugging Face also lands one-click deploy into Amazon SageMaker Studio, deepening its AWS surface.
Simon Willison ships a <github-code> web component built end-to-end from a single GPT-5.5 prompt.

Three unrelated AI-tech ships today, each at a different layer of the stack. Microsoft folded a curated Hugging Face catalog into Foundry Managed Compute as GPU-hour rental, landing above Fireworks and Together on price. SkyPilot started mounting Hugging Face buckets across every major cloud with zero egress, plus Xet chunking that re-uploaded an 8.43 GB blob in 8 seconds. A round-up brief piles on the Hub angle: one-click deploy into Amazon SageMaker Studio.

The third feature sits well outside that orbit: sqlite-utils 4.0 is Simon Willison’s first major bump to the library since 2020, folding schema migrations into core and deliberately shipping without rollback on a fix-forward philosophy. No shared thread — a hyperscaler rental catalog, a storage mount, and a SQLite library release, each worth reading on its own terms.

Azure Foundry rents Hugging Face models by the GPU-hour

Source: huggingface-blog · published 2026-07-07

TL;DR

Microsoft folded a curated Hugging Face catalog into Foundry Managed Compute, renting A100/H100/MI300X GPUs by the hour.
~$8/hr H100 pricing lands above Fireworks (~$7) and Together ($3.49-5.49) on the specialist PaaS market.
Preview only, no SLA — one review clocked a bare “Hi” burning ~2,300 tokens on hidden system prompts.
AWS Bedrock already brokers 83+ HF models on SageMaker JumpStart, making Foundry table stakes rather than a leapfrog.

What actually shipped

Microsoft and Hugging Face have folded a weekly-refreshed catalog of open-weight models into Foundry Managed Compute, a third deployment mode alongside pay-per-token and provisioned throughput. Customers pick a versioned template (e.g. qwen3-32b at 128K context on 2× A100s), Foundry pulls pre-staged weights from Azure storage, and the model comes up behind the same endpoint, auth, and billing as GPT-4o or Claude. Runtimes are the community defaults — vLLM and SGLang for LLMs, TEI for embeddings, llama.cpp for CPU/GGUF, hf-serve for vision and audio.

The pitch is operational: one bill, Entra ID, private VNets, container patches handled by Microsoft, weights staged inside Azure so nothing calls out to the Hub at runtime. For regulated buyers that’s the whole product.

The pricing looks worse than it reads

Foundry’s hourly rates undercut standard Azure VM on-demand — a single H100 VM lists above $12/hr ¹ — but the relevant benchmark isn’t Azure’s own VM sticker price, it’s the specialist PaaS market. Fireworks quotes ~$7/hr for on-demand H100/H200 and claims its FireAttention engine delivers up to +350% capacity over self-hosted vLLM on the same GPUs ². Since Foundry’s default engine is vLLM, that gap flows straight into per-token economics at sustained load.

Provider	H100 on-demand	Default runtime	Notes
Azure Foundry MC	~$8/hr	vLLM / SGLang	Preview, no SLA ³
Azure VM (raw)	$12+/hr	BYO	Spot -80% w/ 30s eviction ¹
Fireworks	~$7/hr	FireAttention	+350% capacity claim vs vLLM ²
Together / Replicate	$3.49-5.49/hr	vLLM-family	Less enterprise glue

The MI300X option looks like real hardware diversity, but TensorWave’s field data puts MI300X at 37-66% of H100/H200 throughput in production kernels depending on ROCm maturity for the specific op ⁴. It’s not a like-for-like capacity swap.

Preview-grade caveats the launch post skips

Microsoft’s own documentation classifies Managed Compute as preview with no SLA, and one hands-on review of the adjacent Foundry Agent Service found a plain “Hi” consuming ~2,300 tokens on background memory and plugin schemas the developer can neither view nor disable ³. That’s a concrete counterexample to the “unified observability” pitch — you get one bill, but you can’t see what it’s for.

The security story needs a similar asterisk. Foundry’s curation strips untrusted code and enforces safetensors, but CVE-2026-4372 demonstrated that a malicious config.json could achieve code execution in Transformers even with trust_remote_code=False ⁵. Curation shrinks the supply-chain surface; it doesn’t close it.

Read it as table stakes, not a moat

AWS Bedrock Marketplace already brokers 83+ Hugging Face models running on SageMaker JumpStart behind Bedrock’s high-level APIs ⁶. Both hyperscalers are converging on the same shape: curated HF catalog, managed GPU PaaS, frontier-model SDK on top. Foundry’s version is a credible enterprise on-ramp for teams already living in Azure — the value is Entra, VNets, and one procurement contract, not price or performance leadership. Treat the “production-ready” framing as marketing until the preview label comes off and an SLA lands.

SkyPilot mounts Hugging Face storage with zero egress fees

Source: huggingface-blog · published 2026-07-07

TL;DR

SkyPilot now mounts Hugging Face buckets across AWS, GCP, Azure and Lambda with $0.00 egress vs. S3’s ~$0.09/GB.
Xet content-defined chunking re-uploaded an 8.43 GB blob in 8 seconds by matching existing chunk hashes.
Lazy FUSE mounting starts a Qwen3.5-4B job in ~30 seconds, with checkpoint writes at 112–168 MB/s.
The catch: MOUNT mode needs glibc 2.34+ and /dev/fuse, ruling out Ubuntu 20.04 and locked-down Kubernetes runtimes.

The egress math is the whole pitch

The cross-cloud transfer tax is real. Akave’s 2025 audit pegs multi-cloud egress at roughly $4,000/month for a 10TB training dataset, with bandwidth routinely eating over 20% of AI infra spend ⁷. That is the number the new SkyPilot + Hugging Face integration is aimed at. By letting a job on Lambda H100s stream weights and checkpoints from an hf:// bucket instead of an S3 bucket in another provider’s region, egress goes to zero — Hugging Face doesn’t bill for it, and CDN pulls are free.

Storage pricing follows the same logic: $12–18/TB/month on Hugging Face Buckets vs. ~$23/TB baseline on S3, before you even count the egress line items that never arrive. The framing isn’t “cheaper than S3” so much as “unpins your GPUs from whichever hyperscaler happens to hold your data.” SkyPilot’s whole value prop is opportunistic GPU sourcing across 20+ vendors; a storage layer that doesn’t punish you for crossing a cloud boundary is the missing piece.

flowchart LR
    HF[(Hugging Face Bucket<br/>Xet-backed, $0 egress)]
    HF -- hf-mount FUSE --> A[AWS L40S]
    HF -- hf-mount FUSE --> G[GCP L4]
    HF -- hf-mount FUSE --> L[Lambda H100]
    A -- checkpoints 168 MB/s --> HF
    G -- checkpoints 123 MB/s --> HF
    L -- checkpoints 112 MB/s --> HF

Xet is the part competitors can’t copy on a price sheet

Zero-egress is a pricing choice. Xet is engineering. Hugging Face’s storage backend splits files into ~64 KB content-defined chunks using GearHash and UltraCDC, so a 50 GB model with a small edit re-uploads only the modified chunks ⁸. That’s what produces the eye-catching numbers in the launch: the 8.43 GB re-upload in 8 seconds (chunk hashes already existed), and the 10 MB delta for a 10k-row append to a 100k-row Parquet file that would otherwise be a 106 MB PUT.

For anyone checkpointing frozen-backbone fine-tunes or shipping quantized variants of a shared base, this is the difference between paying to move whole model files and paying for the diffs. Object stores that treat each PUT as an opaque blob — S3, R2, B2 — structurally can’t match this.

FUSE is the load-bearing assumption, and it’s contested

The skeptical read lives at the mount layer. Gaul’s canonical s3fs analysis lays out the fundamental trade: object-store FUSE drivers either honor POSIX and pay latency, or prioritize throughput and break semantics ⁹. Practitioners on r/aws are blunter, calling FUSE mounts under concurrent writes or database workloads “monstrosities” ¹⁰. AWS’s own Mountpoint-S3 hit the same wall — no in-place file modification, forcing developers to refactor checkpoint code ¹¹. hf-mount is a new implementation of a well-worn problem, not a solved one.

The deployment surface is narrower than the blog implies, too. Independent coverage flags that MOUNT mode’s glibc 2.34+ and /dev/fuse requirement excludes Ubuntu 20.04 hosts and unprivileged-container Kubernetes runtimes — a meaningful slice of enterprise environments ¹². Those users fall back to COPY mode, which downloads eagerly and throws away the “training-ready in 30 seconds” advantage that’s half the point.

The economics check out and Xet is genuinely novel. Whether hf-mount survives contact with production checkpoint code is the open question.

sqlite-utils 4.0 adds migrations, skips rollback on purpose

Source: simon-willison · published 2026-07-07

TL;DR

sqlite-utils 4.0 is the first major bump since 2020, folding the long-beta sqlite-migrate package into the core library.
Three headline features: schema migrations, nested db.atomic() transactions, and compound foreign keys — plus a breaking db.query()/db.execute() split.
Migrations deliberately ship without rollback, breaking with yoyo and goose on the “fix-forward is safer” philosophy.
Claude Fable 5, reviewing the release candidate, flagged 4 blockers and 10 more issues — reshaping the final release.

What actually shipped

The 124th release of sqlite-utils is the first to earn a major version bump in nearly six years, and it lands with three features that reshape how the library is used in the Datasette/LLM ecosystem. Schema migrations — previously the domain of a separate sqlite-migrate package that never made it out of beta — are now first-class. Migrations are Python files decorated with @migrations(), tracked in an internal _sqlite_migrations table, and applied via uvx sqlite-utils migrate data.db migrations.py.

The migration engine leans on the existing table.transform() method, which sidesteps SQLite’s anemic ALTER TABLE by rebuilding tables from scratch. That pattern is the one SQLite’s own docs recommend — but there’s a footgun the release post glosses over: table.transform() silently drops triggers, views, and non-primary indexes when it rebuilds the table, and it’s on the developer to restore them via table.transform_sql() ¹³. For anyone running non-trivial schemas, that’s a sharper edge than the marketing suggests.

Underneath migrations sits a new db.atomic() context manager built on SQLite savepoints, giving the library predictable nested transactions for the first time. Compound foreign keys round out the trio, at the cost of a breaking change to table.foreign_keys introspection.

The deliberate omission

The design choice that separates this from Alembic, yoyo, and Go’s goose is no down migrations ¹⁴. Willison’s stated reasoning is pragmatic — copy the SQLite file before applying changes if you need rollback — and the r/Python discussion frames this as philosophical alignment with modern fix-forward deployment, not a missing feature ¹⁴. It’s a defensible position, but it means teams migrating from tools with robust rollback machinery are giving something up.

The apsw-utils dissent

The most substantive external critique isn’t about features — it’s about foundations. Jeremy Howard’s apsw-utils fork exists because he considers CPython’s sqlite3 transaction handling unsuited to SQLite’s actual semantics, a gap widened by Python 3.12+‘s autocommit changes ¹⁵. The new db.atomic() addresses many of the same pain points Howard raised, but sqlite-utils explicitly does not adopt the 3.12+ autocommit modes, keeping the two projects on divergent paths ¹⁵. If you care about high-concurrency workloads, that architectural disagreement is unresolved.

AI as release engineer

The most-discussed artifact of the release is PR #779, where Claude Fable 5 — given an open-ended “try out every 4.0 feature and report what breaks” prompt — wrote 12 repro scripts and flagged 4 release blockers plus 10 additional issues. GPT-5.5 in Codex Desktop, given the same brief, wrote 5 scripts and found nothing interesting. Independent coverage confirms one of Fable’s catches was genuinely nasty: delete_where() was executing raw SQL outside atomic(), poisoning subsequent transactions with a stuck in_transaction=True state and causing silent data loss on connection close ¹⁶. That’s exactly the kind of state-machine bug humans routinely ship.

The cost side is less flattering. Willison’s earlier writeup on Fable 5 documents spending over $110 in a single day of testing, which pushed him to build a subagent delegation strategy to preserve his token allowance ¹⁷. And HN commenters pushed back on the workflow — prompting an agent from a phone during social events, they argued, risks “half-assed solutions” dressed up as productivity ¹⁸. The 4.0 release is a persuasive proof-of-concept for agent-assisted maintenance. Whether the model generalizes past a single disciplined maintainer is a separate question.

Round-ups

Hugging Face adds one-click deploy to Amazon SageMaker Studio

Source: huggingface-blog

Hugging Face models now port into Amazon SageMaker Studio through a single button, skipping the manual environment setup that usually precedes fine-tuning or inference. The integration targets enterprise teams already on AWS who want faster access to the Hub’s open model catalog.

Simon Willison ships a GitHub-embed web component built by GPT-5.5

Source: simon-willison

A new tag accepts any GitHub blob URL, rewrites it to raw.githubusercontent.com, and renders the specified line range with numbers. Willison built the whole component from a single prompt to GPT-5.5, including a live browser preview during iteration.

Ars Technica maps the path to general-purpose robot autonomy

Source: ars-technica-ai

Researchers and founders at Boston Dynamics, Agility, and Physical Intelligence walk through how learned policies and physical AI are pushing robots past scripted tasks toward workplace and eventually domestic deployment. The piece surveys where autonomy still breaks down across industrial, surgical, and home settings.

Thunder Compute — Azure GPU instances guide — https://www.thundercompute.com/blog/azure-gpu-instances

a single H100 can cost over $12/hour [on standard Azure VM on-demand rates]… spot instances provide up to an 80% discount, though they carry a significant risk with only a 30-second eviction notice

↩ ↩²
Fireworks AI blog — Why GPUs on-demand — https://fireworks.ai/blog/why-gpus-on-demand

Fireworks AI’s on-demand H100/H200 deployments are priced at $7.00 per hour… proprietary ‘FireAttention’ engine provides up to 350% higher capacity than standard self-hosted vLLM on identical hardware

↩ ↩²
Julian Smiles (Medium) — Foundry Agent Service technical limitations — https://medium.com/@juliansmiles_40140/azure-ai-foundry-agent-service-technical-limitations-6b0f00ff4adc

a simple ‘Hi’ response consumes upwards of 2,300 tokens due to background infrastructure for memory and plugin schemas that cannot be disabled or viewed by the user… managed compute is currently in preview, lacks a Service Level Agreement (SLA) and is explicitly not recommended for production workloads

↩ ↩²
TensorWave blog — MI300X in production — https://tensorwave.com/blog/mi300x-2

real-world performance often settles between 37% and 66% of H100/H200 levels depending on the maturity of the ROCm software stack for specific kernels

↩
Shahadil H. (Medium) — Malicious Hugging Face models — https://medium.com/@shahadilh18/why-malicious-hugging-face-models-are-the-security-threat-developers-are-ignoring-8aef643c7f2b

CVE-2026-4372, a critical flaw in the Transformers library that allowed malicious models to execute code via the config.json file even when trust_remote_code=False was set… simply using ‘safe’ weight formats like Safetensors does not eliminate all execution paths

↩
ExploreAgentic — Bedrock vs SageMaker — https://www.exploreagentic.ai/insights/bedrock-vs-sagemaker/

AWS Bedrock Marketplace now hosts 83+ Hugging Face models accessible via Bedrock’s high-level APIs but running on SageMaker JumpStart infrastructure

↩
Akave — egress cost analysis — https://akave.com/blog/cloud-storage-egress-fees-are-costing-your-ai-projects-more-than-you-think

a 10TB training dataset in a multi-cloud configuration can incur roughly $4,000 per month in egress fees alone… bandwidth costs often exceed 20% of the total monthly spend

↩
Hugging Face — ‘From Files to Chunks’ (Xet) — https://huggingface.co/blog/from-files-to-chunks

Xet uses GearHash and UltraCDC… small edits to 50GB models only trigger the upload of modified 64KB chunks rather than entire files

↩
gaul.org — ‘s3fs tradeoffs’ talk — https://www.gaul.org/talks/s3fs-tradeoffs/

goofys prioritizes ‘performance first and POSIX second’… s3fs frequently communicates with S3 to maintain full POSIX consistency, which introduces significant latency

↩
r/aws — ‘Why is s3fs such a bad idea?’ — https://www.reddit.com/r/aws/comments/dplfoa/why_is_s3fs_such_a_bad_idea/

using FUSE mounts for database files or heavy concurrent writes often leads to corruption or performance ‘monstrosities’

↩
Last Week in AWS — ‘S3 is not a filesystem’ — https://www.lastweekinaws.com/blog/s3-is-not-a-filesystem-but-now-theres-one-in-front-of-it/

Mountpoint-S3 cannot modify existing files or handle certain common filesystem flags, often requiring developers to refactor their saving logic

↩
LetsDataScience — independent coverage — https://letsdatascience.com/news/hugging-face-adds-skypilot-storage-backend-e31d5b51

The MOUNT mode requires glibc >= 2.34 and direct /dev/fuse access… making it incompatible with older Linux distributions like Ubuntu 20.04 or locked-down Kubernetes runtimes that use unprivileged containers

↩
sqlite-utils Python API docs (table.transform) — https://sqlite-utils.datasette.io/en/stable/python-api.html

Because the original table is dropped and replaced, any associated triggers, views, or indexes that are not explicitly recreated are lost during the process… developers must manually identify and restore these objects or use table.transform_sql().

↩
r/Python thread on database migrations — https://www.reddit.com/r/Python/comments/1q7ixsf/database_migrations/

The design of sqlite-utils is unique for explicitly avoiding ‘down’ migrations (rollbacks), under the philosophy that fixing errors with new ‘forward’ migrations is safer in production — this differs from yoyo and goose, which both provide robust rollback mechanisms.

↩ ↩²
AI Weekly summary of sqlite-utils 4.0rc1 — https://aiweekly.co/alerts/sqlite-utils-40rc1-brings-migrations-and-nested-transactions

Jeremy Howard (AnswerDotAI) created apsw-utils, a port of sqlite-utils built on APSW… arguing that Python 3.12+ changes to transaction handling are suboptimal compared to the ‘idiomatic’ behavior of the apsw library.

↩ ↩²
AI Weekly writeup of PR #779 — https://aiweekly.co/alerts/sqlite-utils-40rc1-brings-migrations-and-nested-transactions

delete_where() previously executed raw SQL without an atomic() wrapper… This omission left the connection in a permanent in_transaction=True state, ‘poisoning’ subsequent db.atomic() calls… users experienced silent data loss upon closing the database.

↩
Simon Willison — ‘Claude Fable 5 is relentlessly proactive’ — https://simonwillison.net/2026/Jun/9/claude-fable-5/

Fable 5 is priced at $10 per million input and $50 per million output tokens… Willison reported spending over $110 in a single day of testing, leading him to develop a ‘subagent’ strategy to preserve his token allowance.

↩
Hacker News discussion (news.ycombinator.com/item?id=48791708) — https://news.ycombinator.com/item?id=48791708

Constant prompting from mobile devices—even during social events—could lead to burnout and ‘half-assed solutions’ that lack deep focus.

↩

Azure rents HF at $8/hr, SkyPilot zeros egress, sqlite-utils 4.0 skips rollback

Azure rents HF at $8/hr, SkyPilot zeros egress, sqlite-utils 4.0 skips rollback

TL;DR

Azure Foundry rents Hugging Face models by the GPU-hour

TL;DR

What actually shipped

The pricing looks worse than it reads

Preview-grade caveats the launch post skips

Read it as table stakes, not a moat

SkyPilot mounts Hugging Face storage with zero egress fees

TL;DR

The egress math is the whole pitch

Xet is the part competitors can’t copy on a price sheet

FUSE is the load-bearing assumption, and it’s contested

sqlite-utils 4.0 adds migrations, skips rollback on purpose

TL;DR

What actually shipped

The deliberate omission

The apsw-utils dissent

AI as release engineer

Further reading

Round-ups

Hugging Face adds one-click deploy to Amazon SageMaker Studio

Simon Willison ships a GitHub-embed web component built by GPT-5.5

Ars Technica maps the path to general-purpose robot autonomy

Jack Sun, writing.

Azure rents HF at $8/hr, SkyPilot zeros egress, sqlite-utils 4.0 skips rollback

TL;DR

Azure Foundry rents Hugging Face models by the GPU-hour

TL;DR

What actually shipped

The pricing looks worse than it reads

Preview-grade caveats the launch post skips

Read it as table stakes, not a moat

SkyPilot mounts Hugging Face storage with zero egress fees

TL;DR

The egress math is the whole pitch

Xet is the part competitors can’t copy on a price sheet

FUSE is the load-bearing assumption, and it’s contested

sqlite-utils 4.0 adds migrations, skips rollback on purpose

TL;DR

What actually shipped

The deliberate omission

The apsw-utils dissent

AI as release engineer

Further reading

Round-ups

Hugging Face adds one-click deploy to Amazon SageMaker Studio

Simon Willison ships a GitHub-embed web component built by GPT-5.5

Ars Technica maps the path to general-purpose robot autonomy

Footnotes

Jack Sun, writing.