Committee

This story originally appeared in The Algorithm, our weekly newsletter on AI. To get stories like this in your inbox first, sign up here. For those of you enjoying your summer unaware of Anthropic’s latest feud with the US government, here’s a recap: In April the company said it had built an AI model called Mythos that was so good at working with code it could pose a global cybersecurity threat. Anthropic gave access to a small group of cybersecurity experts so they could see what they were up against. Then it released a modified version called Fable which it said was safer to the public on Tuesday, June 9. That Friday, the federal government told the company it was a threat to national security and placed export controls on the new release. Anthropic revoked access to both models hours later. People worried about catastrophic effects of AI—broadly labeled “doomers”—have said for years that the technology poses a threat to humanity and published proposals for how the government should intervene in its development. The doomers just got their government intervention—not over a bioweapon or rogue AI, but in response to an AI model that’s basically just really good at coding. And the result so far looks less like a safety plan than like a superficial reaction. There’s plenty to dissect about what happened in those few days that led to such drastic action from the government, and it’s notable that Amazon CEO Andy Jassy was the one who told government officials that Fable would be dangerous (Amazon is both invested in Anthropic and building its own competing AI models). It’s also possible this will be a short-lived ban from the government that doesn’t survive legal scrutiny (it’s not clear that Anthropic’s offering access to Fable really counts as “exporting” it, for example).  But there are ripple effects happening already.  For one, this is making a whole lot of people not want to rely on American AI companies. TheFrench politician Bruno Retailleau described it as a “wake-up call” that should motivate Europe to build more AI. But any vision of turning Paris into Silicon Valley—touted by many other European leaders following the shutdown of Anthropic’s models—is complicated by one big thing: China.  Open-source models from China are very capable and incredibly cheap, and they can be downloaded to run on anyone’s servers with no rules or guardrails. (This makes them attractive to companies that don’t want access turned off on the basis of a decision from the White House—but equally attractive to cybercriminals, the type that Anthropic hoped to fend off by building safety guardrails into its models.)  It’s possible that companies, including those in the US and Europe, will decide that working with Chinese models is just easier, as the skyrocketing of shares in the Chinese startup Zhipu suggests. Playing this forward, is it possible the government’s next drastic decision will be to say that US companies using models from China pose a threat to national security? I wouldn’t write it off.  Second, it’s possible that shutting off access to Anthropic’s models will leave the country morevulnerable to cybersecurity attacks, not less. Leading cybersecurity experts have said as much in an open letter to the government, writing that access to Anthropic’s models was helping researchers prepare defenses, and that the company’s models are no more dangerous than other leading models that are widely available. Such is the risk of applying the concept of nonproliferation to software—trying to control and restrict dangerous AI models in the manner of the uranium used for nuclear weapons.  The third thing worth watching is how US lawmakers will react. Remember that following Anthropic’s last feud with the government over how the Pentagon could or could not use its models, a slate of new bills was introduced that would define the limits of military AI. Right now, the biggest players shaping how AI gets used are the companies and the White House. There’s been much talk about more federal AI regulation, and polling suggests most Americans want it. Lawmakers are still figuring out whether to form rules on how kids use chatbots and are far from a clear answer on the extent to which the government should vet the safety of AI models. But with every drastic action from the White House, the pressure for regulations rises. To state the obvious, predictions are hard when the administration’s attitudes toward AI  change with the wind. When President Trump took office, he threw out the restrictive rulebook for how to make AI safe and promised to get out of the way of tech companies. The White House has now called the most valuable AI startup a risk to national security once in the spring, and again in summer. What will fall bring?

MoonMath AI team has released a bf16 forward attention kernel for AMD’s MI300X GPU. It is written in HIP, not hand-written assembly. The code is open-source under the MIT license. The MoonMath.ai team reports it beats AITER v3, AMD’s own optimized kernel, on every tested shape. Bare-metal access came from HotAisle, an AMD cloud provider. Attention is the fused softmax(QKᵀ/√d)·V operation inside every transformer. The MI300X is AMD’s CDNA3 data-center GPU, with the ISA target (gfx942). This kernel runs on that hardware only. TL;DR MoonMath.ai open-sources a bf16 forward attention kernel for AMD MI300X, written in HIP, not assembly (MIT). It beats AMD’s AITER v3 on every shape and rounding mode — geomean 1.18×/1.15×/1.08×, up to 1.26×. The core trick: one-instruction asm wrappers let you pick the opcode while the compiler allocates registers. Most of the speedup is memory placement — K in LDS, V hot in L1, Q and accumulators in registers. A real SGLang PR used it to speed up Wan2.1 video diffusion by 1.23×, with no quality regression. Understanding Kernel A kernel is a small program that runs directly on the GPU’s many cores to perform one specific computation—here, the attention math—as fast as the hardware allows. The kernel computes forward attention in bf16 on MI300X only. It takes inputs in either BSHD or BHSD layout, with no transpose. Head dimension is fixed at 128. It supports any sequence length, including cross-attention. There are real limits. There is no causal mask, no GQA, and no varlen batching. Outputs are bf16, and it runs on gfx942 hardware exclusively. Numerics are tightly controlled. All three rounding modes match AITER’s per-mode rounding rule. Every finite output sits within 1 bf16 ULP of AITER. NaN and Inf handling is bit-identical, and results are deterministic. The Core Trick: One-Instruction asm Wrappers The core technique avoids a familiar dilemma. Compiler intrinsics keep code tidy but let the compiler reorder or rename operands. Raw inline assembly gives control but forces manual register and address management. MoonMath wraps exactly one instruction in a __device__ __forceinline__ function. Extended asm constraints describe the operands. The research team picks the opcode. The compiler still allocates registers and tracks data flow. Copy CodeCopiedUse a different Browser // in/out tied to the SAME VGPR → no accumulator rename, no v_mov copy. __device__ __forceinline__ void asm_mfma(bf16x4_t a, bf16x4_t b, fp32x4_t& c) { asm volatile(“v_mfma_f32_16x16x16_bf16 %0, %1, %2, %0” : “+v”(c) : “v”(a), “v”(b)); } The “+v”(c) constraint ties the accumulator input and output to the same VGPR. No copy instruction is emitted. This keeps the kernel close to ordinary HIP. It still steers the machine one instruction at a time. The Architecture: Eight Waves, Two Groups, Two Barriers A CDNA3 compute unit has four SIMD units. The textbook block is four waves. MoonMath instead runs eight waves per block, in two groups of four. The two groups run the same Q*K, softmax, O += P*V sequence. They are offset by a phase. While one group saturates the matrix core, the other runs softmax and issues loads. Then they swap, so the matrix core never idles. There are two s_barriers per iteration. One sits at the phase handoff. One sits at the iteration boundary. Per-counter waits handle the rest of the synchronization. This echoes FlashAttention-3’s matmul and softmax alternation. It does not copy FA3’s producer and consumer warp split. On CDNA3, every memory move is already asynchronous, so a dedicated producer wave is unnecessary. Where Data Lives, and Why 16×16×16 Most of the speedup comes from memory placement. K streams from HBM into LDS, double-buffered, shared by all eight waves. V stays hot in L1, read on every PV matmul. Q and accumulators live in registers. The research team picked the 16×16×16 MFMA over 32×32×8. Both shapes have identical throughput. The smaller tile accumulates into 4 fp32 elements per lane, against 16. Lower accumulator pressure leaves room for deeper prefetch and a third Q tile. Decision Choice Reason Waves per block 8 (two groups of 4) Plan the pipeline directly; share one K copy MFMA shape 16×16×16 bf16 Same throughput, lower VGPR pressure, better power efficiency K placement LDS, double-buffered, 32 KiB Shared by all 8 waves, swapped per iteration V placement L1, resident, prefetched Reread across PV, kept hot deliberately Q + accumulators VGPRs Read every iteration, never reloaded Two later wins close the gap. A third Q tile (3Q) raises data reuse per loaded K and V tile. A Flash-Decoding-style tail KV split rescues the stranded fractional round across MI300X’s 304 CUs. These wins cascade. Moving V to L1 freed the LDS that the third Q tile then fills. Benchmark Tests ran on MI300X in bf16, head dimension 128. Each shape was measured at three rounding modes. RTNE rounds to nearest even. RTNA rounds to nearest, ties away from zero. RTZ truncates toward zero. Shape (B, H, S, D) Round Ours (ms) AITER v3 (ms) vs AITER vs MAX (2, 24, 8192, 128) RTNE 3.083 3.792 1.23× 1.37× (2, 24, 16384, 128) RTNE 11.670 14.691 1.26× 1.54× (4, 16, 16384, 128) RTZ 15.055 16.183 1.07× 1.47× (2, 24, 32768, 128) RTNA 44.440 52.363 1.18× 1.57× (1, 16, 131072, 128) RTNE 232.517 269.278 1.16× 1.46× Geomeans across the sweep favor MoonMath. Versus AITER, it scores 1.18× (RTNE), 1.15× (RTNA), and 1.08× (RTZ). Versus Modular MAX, geomeans run 1.44× to 1.49×, and per-shape speedups reach 1.59×. RTZ is AITER’s own fastest mode and the tightest race. The (4, 16, 16384) RTZ shape moved from 0.95× to 1.07×. The tail KV split is what closed that final gap. Interactive Explainer Use Cases The kernel installs with pip and exposes a small API. It launches on the caller’s stream, so it overlaps inside larger pipelines. Copy CodeCopiedUse a different Browser import torch import moonmath_attention as ma # PyTorch’s ROCm build uses the “cuda” device string on AMD GPUs q = torch.randn(2, 8192, 24, 128, dtype=torch.bfloat16, device=”cuda”) k = torch.randn(2, 8192, 24, 128, dtype=torch.bfloat16, device=”cuda”) v = torch.randn(2, 8192, 24, 128, dtype=torch.bfloat16, device=”cuda”) out

In this tutorial, we build a Prefab application that demonstrates how to create interactive dashboards entirely in Python. We use Prefab’s component-based Python interface to design a polished operations dashboard with reactive state, charts, tables, filters, forms, tabs, alerts, metrics, and client-side actions. We generate realistic pipeline monitoring data, connect it to live UI controls, and export the final app as a static HTML dashboard that we can preview directly inside Google Colab. Through this workflow, we learn how Prefab lets us move from Python data logic to a modern React-powered user interface without having to write frontend code manually. Installing Prefab in Colab Copy CodeCopiedUse a different Browser import os import sys import base64 import subprocess from pathlib import Path from IPython.display import HTML, display, FileLink PREFAB_VERSION = “0.20.2” APP_PATH = Path(“/content/prefab_advanced_tutorial_app.py”) HTML_PATH = Path(“/content/prefab_advanced_dashboard.html”) subprocess.check_call([ sys.executable, “-m”, “pip”, “install”, “-q”, f”prefab-ui=={PREFAB_VERSION}”, ]) APP_CODE = “” We set up the Colab environment by importing the required Python utilities and defining the Prefab version, app path, and HTML export path. We install the pinned prefab-ui package so that the tutorial runs consistently without version-related issues. We also initialize an empty APP_CODE string, which we use to build the complete Prefab application step by step. Copy CodeCopiedUse a different Browser APP_CODE += r”’ Generating Synthetic Operations Data Copy CodeCopiedUse a different Browser import random from collections import Counter, defaultdict from datetime import date, timedelta from prefab_ui.actions import AppendState, OpenLink, PopState, SetState, ShowToast, ToggleState from prefab_ui.app import PrefabApp from prefab_ui.components import ( Alert, AlertDescription, AlertTitle, Badge, Button, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Code, Column, DataTable, DataTableColumn, Form, Grid, H2, Input, Markdown, Mermaid, Metric, Muted, Progress, Ring, Row, Slider, Small, Switch, Tab, Tabs, Text ) from prefab_ui.components.charts import ( BarChart, ChartSeries, LineChart, PieChart, RadarChart, ScatterChart, Sparkline ) from prefab_ui.components.control_flow import Else, ForEach, If from prefab_ui.rx import EVENT, STATE random.seed(42) TODAY = date.today() DATES = [TODAY – timedelta(days=29 – i) for i in range(30)] REGIONS = [“All”, “APAC”, “EMEA”, “NA”, “LATAM”] PIPELINES = [ “Customer 360 ETL”, “Invoice OCR”, “LLM Triage”, “Risk Scoring”, “Forecast Sync”, “Warehouse Load”, ] OWNERS = [“Data Platform”, “AI Apps”, “Revenue Ops”, “Risk Engineering”] STATES = [“Completed”, “Completed”, “Completed”, “Completed”, “Late”, “Failed”] PRIORITIES = [“P0”, “P1”, “P2”, “P3”] runs = [] daily_region_rows = [] for d in DATES: for region in REGIONS[1:]: region_bias = { “APAC”: 0.96, “EMEA”: 0.94, “NA”: 0.97, “LATAM”: 0.91, }[region] volume = random.randint(32, 78) failures = 0 late = 0 total_cost = 0.0 total_latency = 0.0 total_revenue = 0.0 for i in range(volume): pipeline = random.choice(PIPELINES) owner = random.choice(OWNERS) state = random.choices( STATES, weights=[ region_bias * 10, 6, 4, 3, 1.2, max(0.2, (1 – region_bias) * 16), ], k=1, )[0] duration = max( 12, int( random.gauss(95, 35) + (20 if state == “Late” else 0) + (45 if state == “Failed” else 0) ), ) cost = round(max(0.09, random.lognormvariate(-1.15, 0.55) + duration / 1800), 2) revenue = round(random.uniform(1.2, 8.5) * (1.3 if state == “Completed” else 0.6), 2) priority = random.choices(PRIORITIES, weights=[1, 3, 7, 10], k=1)[0] if state == “Failed”: failures += 1 if state == “Late”: late += 1 total_cost += cost total_latency += duration total_revenue += revenue if d >= TODAY – timedelta(days=10) and (state in {“Failed”, “Late”} or random.random() < 0.05): runs.append({ “run_id”: f”{d.strftime(‘%m%d’)}-{region[:2]}-{len(runs)+1:04d}”, “date”: d.strftime(“%Y-%m-%d”), “pipeline”: pipeline, “owner”: owner, “region”: region, “state”: state, “priority”: priority, “duration_s”: duration, “cost_usd”: cost, “revenue_k”: revenue, “sla_gap”: round(max(0, duration – 120) / 60, 1), }) daily_region_rows.append({ “date”: d.strftime(“%b %d”), “region”: region, “runs”: volume, “failures”: failures, “late”: late, “success_rate”: round(100 * (volume – failures – late * 0.35) / volume, 1), “avg_latency”: round(total_latency / volume, 1), “cost_usd”: round(total_cost, 2), “revenue_k”: round(total_revenue, 1), }) runs = sorted( runs, key=lambda r: (r[“priority”], r[“state”] != “Failed”, -r[“duration_s”]) )[:80] def aggregate_daily(rows): by_date = defaultdict(lambda: { “date”: “”, “runs”: 0, “failures”: 0, “late”: 0, “cost_usd”: 0.0, “revenue_k”: 0.0, “latency_weighted”: 0.0, }) for r in rows: bucket = by_date[r[“date”]] bucket[“date”] = r[“date”] bucket[“runs”] += r[“runs”] bucket[“failures”] += r[“failures”] bucket[“late”] += r[“late”] bucket[“cost_usd”] += r[“cost_usd”] bucket[“revenue_k”] += r[“revenue_k”] bucket[“latency_weighted”] += r[“avg_latency”] * r[“runs”] out = [] for d in [x.strftime(“%b %d”) for x in DATES]: b = by_date[d] if b[“runs”]: b[“success_rate”] = round(100 * (b[“runs”] – b[“failures”] – b[“late”] * 0.35) / b[“runs”], 1) b[“avg_latency”] = round(b[“latency_weighted”] / b[“runs”], 1) b[“cost_usd”] = round(b[“cost_usd”], 2) b[“revenue_k”] = round(b[“revenue_k”], 1) del b[“latency_weighted”] out.append(dict(b)) return out def aggregate_regions(rows): by_region = defaultdict(lambda: { “region”: “”, “runs”: 0, “failures”: 0, “late”: 0, “cost_usd”: 0.0, “revenue_k”: 0.0, “latency_weighted”: 0.0, }) for r in rows: b = by_region[r[“region”]] b[“region”] = r[“region”] b[“runs”] += r[“runs”] b[“failures”] += r[“failures”] b[“late”] += r[“late”] b[“cost_usd”] += r[“cost_usd”] b[“revenue_k”] += r[“revenue_k”] b[“latency_weighted”] += r[“avg_latency”] * r[“runs”] out = [] for region in REGIONS[1:]: b = by_region[region] b[“success_rate”] = round(100 * (b[“runs”] – b[“failures”] – b[“late”] * 0.35) / b[“runs”], 1) b[“avg_latency”] = round(b[“latency_weighted”] / b[“runs”], 1) b[“cost_usd”] = round(b[“cost_usd”], 2) b[“revenue_k”] = round(b[“revenue_k”], 1) b[“roi”] = round(b[“revenue_k”] / max(1, b[“cost_usd”]), 1) del b[“latency_weighted”] out.append(dict(b)) return out def make_status_rows(table_rows): counts = Counter(r[“state”] for r in table_rows) return [{“state”: k, “count”: v} for k, v in counts.items()] def make_pipeline_rows(table_rows): counts = Counter(r[“pipeline”] for r in table_rows) return [{“pipeline”: k, “count”: v} for k, v in counts.most_common()] def make_kpis(region, daily_rows, table_rows): runs_count = sum(r[“runs”] for r in daily_rows) failures = sum(r[“failures”] for r in daily_rows) late = sum(r[“late”] for r in daily_rows) cost = sum(r[“cost_usd”] for r in daily_rows) revenue = sum(r[“revenue_k”] for r in daily_rows) return { “region”: region, “runs”: runs_count, “success_rate”: round(100 * (runs_count – failures – late * 0.35) / max(1, runs_count), 1), “avg_latency”: round(sum(r[“avg_latency”] * r[“runs”] for r in daily_rows) / max(1, runs_count), 1), “cost_usd”: round(cost, 2), “revenue_k”: round(revenue, 1), “roi”: round(revenue / max(1, cost), 1), “open_issues”: len(table_rows), “p0p1”: sum(1 for r in table_rows if r[“priority”] in {“P0”, “P1”}), “failure_rate”: round(100 * failures / max(1, runs_count), 2), “spark”: [r[“success_rate”] for r in daily_rows[-14:]], } DAILY_BY_REGION = {“All”: aggregate_daily(daily_region_rows)} REGION_ROWS = aggregate_regions(daily_region_rows) for region in REGIONS[1:]: DAILY_BY_REGION[region] = [r for r in daily_region_rows if r[“region”] == region] RUNS_BY_REGION = { region: [r for r in

Nous Research has added a Blank Slate setup mode to its open-source Hermes Agent. It inverts the usual onboarding. Instead of a fully loaded default, you start with almost nothing. Hermes Agent is the self-improving agent framework from Nous Research. It runs on your own machine. The team announced the new mode on X. Blank Slate now joins two existing options: Quick Setup and Full Setup. TL;DR Blank Slate boots an agent with everything off except provider & model, File Operations, and Terminal. Web, browser, code execution, vision, memory, delegation, cron, skills, plugins, and MCP stay disabled. It writes an explicit platform_toolsets.cli list plus agent.disabled_toolsets to pin the surface. Nothing you skipped loads later — not even after hermes update. Re-enable anything with hermes tools, hermes skills opt-in –sync, or hermes setup agent. What is Blank Slate On a fresh install, hermes setup now offers three modes. The choice sets your starting surface area. Quick Setup uses the Nous Portal. It needs no API keys and uses a free OAuth login. It sets up a model plus the Tool Gateway tools. The docs call it the recommended fast path. Full Setup is the opposite. You walk through every provider, tool, and option yourself. You bring your own keys. Blank Slate is the minimal third path. It is for building an agent from the ground up. Everything starts off except the bare minimum needed to run an agent. That minimum is three pieces: provider & model, the File Operations toolset, and the Terminal toolset. The disabled list is explicit. Off by default: web, browser, code execution, vision, memory, delegation, cron, skills, plugins, and MCP servers. Compression, checkpoints, smart routing, and memory capture are also disabled. Hermes Agent has a new Blank Slate setup mode. The default Quick/Full setup modes work great for most, but if you would rather build your agent from the ground up you can now start with just a provider, model, file operations, and terminal, then manually add in anything else. pic.twitter.com/EiFm7tW3Ws — Nous Research (@NousResearch) June 20, 2026 The Two Paths After the Baseline Blank Slate does not stop at the baseline. After the minimal baseline is applied, you choose one of two paths. The first path keeps everything disabled. You finish now with the minimal agent. You get file and terminal access, and nothing else. The second path walks through all configurations. You opt in to tools, skills, plugins, MCP, and messaging. You enable only what each workflow needs. Pick Blank Slate when you want a minimal, fully-controlled agent. The point is to enable exactly what you need and no more. Why the Config Format Matters Blank Slate does not just toggle features at runtime. It writes the decision to disk. The mode writes an explicit platform_toolsets.cli list. It also writes agent.disabled_toolsets. Together, these two keys pin your agent’s surface. The effect is durable. Nothing you did not choose ever loads. That holds even after hermes update. An update cannot silently re-enable a toolset you left off. Hermes also separates secrets from settings. Tokens live in ~/.hermes/.env. Non-secret settings live in ~/.hermes/config.yaml. The CLI routes each value to the correct file. Setup Modes Compared Mode Enabled by default Keys / auth Best for Quick Setup (Nous Portal) Model + Tool Gateway tools Free OAuth, no API keys Fastest first run Full Setup Every tool and option you pick Bring your own keys Hand-tuned, full control Blank Slate Provider & model, File Operations, Terminal Provider auth only Minimal, fully-controlled setups Use Cases With Examples Three situations fit Blank Slate well: A security-sensitive deployment is the first. You want an agent with no web and no browser. Blank Slate ships file and terminal access only. Nothing reaches the network unless you add it. A reproducible team setup is the second. You pin one known toolset across every machine. Updates will not drift the configuration. New tools never appear without an explicit opt-in. A teaching or audit environment is the third. You start minimal and add one toolset at a time. Each capability becomes a deliberate choice. Here is a minimal flow. Install, run setup, choose Blank Slate, then finish now. Copy CodeCopiedUse a different Browser curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash source ~/.bashrc # or source ~/.zshrc hermes setup # choose Blank Slate, then “finish now” hermes # file + terminal only Later, add one capability when a task needs it. Copy CodeCopiedUse a different Browser hermes tools # re-enable a toolset, e.g. web hermes skills opt-in –sync # seed skills on demand hermes setup agent # tune compression, routing, memory A Note for Local Setups Hermes Agent requires a model with at least 64,000 tokens of context. Smaller windows are rejected at startup. Most hosted models meet this easily. Local models need an explicit context size of 64K. For example, use –ctx-size 65536 for llama.cpp. A minimal Blank Slate agent on a local model still has to clear this floor. Interactive Explainer Check out the Technical details. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us The post Nous Research Updates Hermes Agent With a Blank Slate Mode That Pins Toolsets via platform_toolsets.cli and disabled_toolsets appeared first on MarkTechPost.

In this tutorial, we build a full Crawlee-for-Python workflow that covers environment setup, local website generation, static crawling, dynamic crawling, structured extraction, and downstream data processing. We begin by configuring a compatible Crawlee runtime with pinned Pydantic support, Playwright browser installation, persistent storage directories, and Colab-safe execution handling. We then generate a realistic local demo website containing product pages, documentation pages, blog content, internal links, robots.txt rules, JSON-LD metadata, and JavaScript-rendered catalog items. Using BeautifulSoupCrawler, we perform fast recursive HTML crawling and extract page titles, metadata, text previews, outgoing links, product attributes, documentation headings, code blocks, and blog tags. With ParselCrawler, we run precise CSS- and XPath-based extraction on product detail pages. With PlaywrightCrawler, we render JavaScript content in a headless Chromium browser, wait for dynamic DOM elements to appear, extract client-side data, and capture full-page screenshots. Setting Up the Crawlee Python Runtime and Helpers Copy CodeCopiedUse a different Browser import os import sys import re import csv import json import time import math import shutil import socket import hashlib import asyncio import textwrap import subprocess import threading from pathlib import Path from functools import partial from http.server import ThreadingHTTPServer, SimpleHTTPRequestHandler from importlib.metadata import version, PackageNotFoundError SETUP_SENTINEL = “/content/.crawlee_python_tutorial_setup_done_v2″ def sh(command, check=True, quiet=False): print(f”n$ {command}”) result = subprocess.run( command, shell=True, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, ) if not quiet and result.stdout: print(result.stdout[-5000:]) if check and result.returncode != 0: raise RuntimeError(f”Command failed with exit code {result.returncode}: {command}”) return result.returncode == 0 def package_version(package_name): try: return version(package_name) except PackageNotFoundError: return None def is_good_pydantic_version(v): if not v: return False m = re.match(r”^(d+).(d+)”, v) if not m: return False major, minor = int(m.group(1)), int(m.group(2)) return major == 2 and minor == 11 current_crawlee = package_version(“crawlee”) current_pydantic = package_version(“pydantic”) needs_setup = ( not os.path.exists(SETUP_SENTINEL) or current_crawlee is None or not is_good_pydantic_version(current_pydantic) ) if needs_setup: print(“PHASE 1: Installing compatible Crawlee + Pydantic + Playwright dependencies.”) print(“After this finishes, Colab will restart automatically. Then run this same cell again.”) sh(f'{sys.executable} -m pip uninstall -y crawlee pydantic pydantic-core’, check=False) sh( f'{sys.executable} -m pip install -q -U ‘ f'”pydantic>=2.11,<2.12″ ‘ f'”crawlee[all]” ‘ f’pandas matplotlib networkx nest_asyncio beautifulsoup4 parsel’ ) sh(f'{sys.executable} -m playwright install –with-deps chromium’, check=False) Path(SETUP_SENTINEL).write_text(“done”, encoding=”utf-8″) print(“nInstalled versions:”) sh(f'{sys.executable} -m pip show crawlee pydantic pydantic-core’, check=False) try: import google.colab print(“nRestarting Colab runtime now. After it reconnects, run this same cell again.”) os.kill(os.getpid(), 9) except Exception: raise SystemExit(“Setup complete. Restart the runtime/kernel manually, then run this cell again.”) print(“PHASE 2: Dependencies are ready. Running the Crawlee tutorial.”) import pandas as pd import matplotlib.pyplot as plt import networkx as nx import nest_asyncio nest_asyncio.apply() TUTORIAL_ROOT = Path(“/content/crawlee_python_advanced_tutorial”) SITE_DIR = TUTORIAL_ROOT / “demo_site” OUTPUT_DIR = TUTORIAL_ROOT / “outputs” STORAGE_DIR = TUTORIAL_ROOT / “crawlee_storage” SCREENSHOT_DIR = OUTPUT_DIR / “screenshots” for path in [SITE_DIR, OUTPUT_DIR, STORAGE_DIR]: if path.exists(): shutil.rmtree(path) for path in [SITE_DIR, OUTPUT_DIR, STORAGE_DIR, SCREENSHOT_DIR]: path.mkdir(parents=True, exist_ok=True) os.environ[“CRAWLEE_STORAGE_DIR”] = str(STORAGE_DIR) os.environ[“CRAWLEE_LOG_LEVEL”] = “INFO” os.environ[“CRAWLEE_PURGE_ON_START”] = “true” from crawlee import Glob, ConcurrencySettings from crawlee.crawlers import ( BeautifulSoupCrawler, BeautifulSoupCrawlingContext, ParselCrawler, ParselCrawlingContext, PlaywrightCrawler, PlaywrightCrawlingContext, ) try: import crawlee print(“Crawlee version:”, crawlee.__version__) except Exception: print(“Crawlee imported successfully.”) print(“Pydantic version:”, package_version(“pydantic”)) def safe_slug(value): value = re.sub(r”[^a-zA-Z0-9]+”, “-“, str(value)).strip(“-“).lower() return value or “item” def money_to_float(value): if value is None: return None cleaned = re.sub(r”[^0-9.]”, “”, str(value)) return float(cleaned) if cleaned else None def normalize_text(value, max_len=None): value = re.sub(r”s+”, ” “, value or “”).strip() return value[:max_len] if max_len else value def write_file(path, content): path = Path(path) path.parent.mkdir(parents=True, exist_ok=True) path.write_text(textwrap.dedent(content).strip() + “n”, encoding=”utf-8″) We begin by preparing the complete Colab runtime for the Crawlee tutorial. We install compatible versions of Crawlee, Pydantic, Playwright, and the required analysis libraries, and handle the automatic restart required after setup. We then configure storage folders, environment variables, crawler imports, and helper functions to ensure the rest of the workflow runs smoothly. Generating the Demo Website and Product Catalog Copy CodeCopiedUse a different Browser PRODUCTS = [ { “sku”: “CRW-101”, “name”: “Crawler Reliability Kit”, “category”: “automation”, “price”: 149.0, “rating”: 4.8, “stock”: 18, “features”: [“retry policy”, “queue replay”, “structured logs”], “related”: [“CRW-202”, “CRW-303”], }, { “sku”: “CRW-202”, “name”: “Playwright Rendering Pack”, “category”: “browser”, “price”: 249.0, “rating”: 4.7, “stock”: 9, “features”: [“headless chromium”, “screenshots”, “dynamic DOM extraction”], “related”: [“CRW-101”, “CRW-404”], }, { “sku”: “CRW-303”, “name”: “RAG Extraction Bundle”, “category”: “ai-data”, “price”: 199.0, “rating”: 4.9, “stock”: 13, “features”: [“clean text chunks”, “metadata capture”, “JSONL export”], “related”: [“CRW-101”, “CRW-505”], }, { “sku”: “CRW-404”, “name”: “Anti-Fragile Session Toolkit”, “category”: “resilience”, “price”: 299.0, “rating”: 4.6, “stock”: 5, “features”: [“session rotation”, “state recovery”, “graceful failures”], “related”: [“CRW-202”, “CRW-505”], }, { “sku”: “CRW-505”, “name”: “Data Export Control Plane”, “category”: “storage”, “price”: 179.0, “rating”: 4.5, “stock”: 21, “features”: [“datasets”, “key-value store”, “CSV and JSON export”], “related”: [“CRW-303”, “CRW-404″], }, ] def layout(title, body, extra_head=””, extra_script=””): css = “”” <style> body { font-family: Inter, system-ui, -apple-system, BlinkMacSystemFont, “Segoe UI”, sans-serif; margin: 0; background: #f7f7fb; color: #1f2430; } header { background: #202638; color: white; padding: 28px 40px; } nav a { color: #dbe7ff; margin-right: 18px; text-decoration: none; font-weight: 600; } main { max-width: 1050px; margin: 0 auto; padding: 32px; } .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(230px, 1fr)); gap: 18px; } .card, article, .panel { background: white; border: 1px solid #e5e7ef; border-radius: 16px; padding: 20px; box-shadow: 0 8px 25px rgba(20, 30, 60, 0.05); } .price { font-size: 1.3rem; font-weight: 800; } .tag { display: inline-block; background: #edf2ff; border: 1px solid #d6e0ff; border-radius: 999px; padding: 4px 10px; margin: 3px; font-size: 0.82rem; } .stock-low { color: #b42318; font-weight: 700; } .stock-ok { color: #067647; font-weight: 700; } code, pre { background: #111827; color: #d1fae5; border-radius: 10px; } pre { padding: 16px; overflow-x: auto; } footer { padding: 30px 40px; color: #606779; } </style> “”” return f””” <!doctype html> <html lang=”en”> <head> <meta charset=”utf-8″> <meta name=”viewport” content=”width=device-width, initial-scale=1″> <meta name=”description” content=”{title} page for a Crawlee Python tutorial demo website.”> <title>{title}</title> {css} {extra_head} </head> <body> <header> <h1>{title}</h1> <nav> <a href=”/index.html”>Home</a> <a href=”/products/product-crw-101.html”>Products</a> <a href=”/docs/getting-started.html”>Docs</a> <a href=”/blog/crawling-at-scale.html”>Blog</a> <a href=”/dynamic.html”>Dynamic JS Page</a> <a href=”/admin/hidden.html”>Admin</a> </nav> </header> <main>{body}</main> <footer>Local demo website generated for Crawlee Python advanced tutorial.</footer> {extra_script} </body> </html> “”” def build_demo_site(): write_file( SITE_DIR / “robots.txt”, “”” User-agent: * Disallow: /admin/ Allow: /