Committee

In the first week of the landmark trial between Elon Musk and OpenAI, Musk took the stand in a crisp black suit and tie and argued that OpenAI CEO Sam Altman and president Greg Brockman had deceived him into bankrolling the company. Along the way, he warned that AI could destroy us all and sat through revelations that he had poached OpenAI employees for his own companies. He even confessed, to some audible gasps in the courtroom, that his own AI company, xAI, which makes the chatbot Grok, uses OpenAI’s models to train its own.  The federal courthouse in Oakland, California, was packed with armies of lawyers carrying boxes of exhibits, journalists typing away at their laptops, and a handful of concerned OpenAI employees. Outside, protesters lined the streets, carrying signs urging people to quit ChatGPT, boycott Tesla, or both. Musk looked calm and comfortable, slipping in the occasional quip in his distinct South African accent. But he also was full of remorse.  “I was a fool who provided them free funding to create a startup,” Musk told the jury. He said when he cofounded OpenAI in 2015 with Altman and Brockman, he was donating to a nonprofit developing AI for the benefit of humanity, not to make the executives rich. “I gave them $38 million of essentially free funding, which they then used to create what would become an $800 billion company,” he said. Musk is asking the court to remove Altman and Brockman from their roles and to unwind the restructuring that allowed OpenAI to operate a for-profit subsidiary. The outcome of the trial could upend OpenAI’s race toward an IPO at a valuation approaching $1 trillion. Meanwhile, xAI is expected to go public as a part of Musk’s rocket company SpaceX as early as June, at a target valuation of $1.75 trillion. This week’s testimony revolved around a central question of the trial: why Musk is suing OpenAI. Musk argued he was trying to save OpenAI’s mission to develop AI safely by restoring the company to its original nonprofit structure. OpenAI’s lawyer, William Savitt, who once represented Musk and his electric-car company Tesla, countered that Musk was “never committed to OpenAI being a nonprofit” and instead was suing to undermine his competitor.  Who is the steward of AI safety? During his direct examination early in the week, Musk painted himself as a longtime advocate of AI safety. He said he cofounded OpenAI to create a “counterbalance to Google,” which was leading the AI race at the time. He said that when he asked Google cofounder Larry Page what happens if AI tries to wipe out humanity, Page told him, “That will be fine as long as artificial intelligence survives.”  “The worst-case scenario is a Terminator situation where AI kills us all,” Musk later told the jury. Savitt stood at the lectern and argued that Musk was not a “paladin of safety and regulation.” As he cross-examined Musk in his sharp, surgical cadence, Savitt pointed out that xAI sued the state of Colorado in April over an AI law designed to prevent algorithmic discrimination.  Musk’s lawyer, Steven Molo, sprang to his feet to object. He asked the judge if he, too, could weigh in on ChatGPT’s safety record.  The lawyers then entered a heated debate about who was the true guardian of AI safety.  The sparring continued the next morning. “We all could die as a result of artificial intelligence!” said Molo, suggesting that OpenAI could not be trusted to build AI safely. “Despite these risks, your client is creating a company that’s in the exact space,” Judge Yvonne Gonzalez Rogers said sternly, referring to xAI. “I suspect there’s plenty of people who don’t want to put the future of humanity in Mr. Musk’s hands.” When the lawyers began talking over each other, the judge snapped. “This is not a trial on whether or not artificial intelligence has damaged humanity,” she said.  When did Musk think he was being duped? As Savitt continued to cross-examine Musk, he pressed on the idea that Musk had never been committed to keeping OpenAI a nonprofit. He also claimed that Musk waited too long to sue OpenAI, filing after the statute of limitations ran out.  Musk explained why he sued in 2024 rather than earlier, describing “three phases” in his views of OpenAI. In phase one, he was “enthusiastically supportive” of the company.” In phase two, “I started to lose confidence that they were telling me the truth,” he said. In phase three, “I’m sure they’re looting the nonprofit.”  In 2017, Musk and other OpenAI cofounders discussed creating a for-profit subsidiary to raise enough capital to build artificial general intelligence—powerful AI that can compete with humans on most cognitive tasks. Musk wanted a majority interest in the subsidiary and the right to choose a majority of the board members. He also pitched having Tesla acquire OpenAI. (He left OpenAI in 2018.) “I was not opposed to there being a small for-profit that provides funding to the nonprofit,” he told the jury, “as long as the tail didn’t wag the dog.”  But it was only in late 2022, Musk testified, that he “lost trust in Altman” and his commitment to keeping the company a nonprofit. The key moment came, he said, when he learned that Microsoft would invest $10 billion in OpenAI.  “I texted Sam Altman, ‘What the hell is going on? This is a bait and switch,’” he told the jury. Microsoft would give $10 billion only if it expected “a very big financial return,” he said. Is Musk just trying to kill competition? But Savitt argued that Musk was really suing to undermine OpenAI as a competitor to his empire of tech companies. While he was on the board of OpenAI, Musk was also running Tesla and his brain-implant company, Neuralink. He founded xAI in 2023. Savitt pulled up an email that Musk had sent to a Tesla vice president in 2017 after hiring Andrej Karpathy, a founding member of OpenAI,

In this tutorial, we explore how we can decode linguistic features directly from brain signals using a modern neuroAI pipeline. We work with MEG data and build an end-to-end system that transforms raw neural activity into meaningful predictions, in this case, estimating word length from brain responses. We set up the environment, load and process neural events, design a custom feature extractor, and construct a structured data pipeline using NeuralSet. From there, we train a convolutional neural network to learn patterns in the temporal and spatial structure of MEG signals. Throughout the process, we focus on building a clean, modular workflow that mirrors real-world neuroAI research practices. Copy CodeCopiedUse a different Browser import subprocess, sys, importlib, pkgutil def pip_install(*pkgs): print(f”pip install {‘ ‘.join(pkgs)} …”) r = subprocess.run([sys.executable, “-m”, “pip”, “install”, “-q”, *pkgs], capture_output=True, text=True) if r.returncode != 0: print(“pip STDOUT:”, r.stdout[-2000:]) print(“pip STDERR:”, r.stderr[-2000:]) raise RuntimeError(“pip install failed; see output above.”) print(” ok”) pip_install(“numpy>=2.0,<2.3”) pip_install(“neuralset”) pip_install(“neuralfetch”) import numpy as np from numpy._core.umath import _center print(f”numpy {np.__version__} OK”) import warnings, typing as tp warnings.filterwarnings(“ignore”) import pandas as pd import torch import torch.nn as nn import torch.nn.functional as F from torch.utils.data import DataLoader import matplotlib.pyplot as plt import neuralset as ns from neuralset import extractors as ext_mod We install and validate all required dependencies, ensuring critical packages such as NumPy and NeuralSet are properly configured. We perform a quick NumPy check to avoid runtime issues later in the pipeline. We then import all core libraries needed for data processing, modeling, and visualization. Copy CodeCopiedUse a different Browser def deep_import(pkg_name: str): try: pkg = importlib.import_module(pkg_name) except Exception as e: print(f” could not import {pkg_name}: {e}”) return if not hasattr(pkg, “__path__”): return for m in pkgutil.walk_packages(pkg.__path__, prefix=pkg_name + “.”): try: importlib.import_module(m.name) except Exception: pass deep_import(“neuralfetch”) deep_import(“neuralset”) torch.manual_seed(0); np.random.seed(0) catalog = ns.Study.catalog() print(f”n{len(catalog)} studies registered.”) preferred = [“Fake2025Meg”, “Test2025Meg”, “Test2023Meg”] study_name = next((n for n in preferred if n in catalog), None) if study_name is None: meg_studies = [n for n, c in catalog.items() if “Meg” in c.neuro_types()] study_name = meg_studies[0] if meg_studies else None if study_name is None: raise RuntimeError( “No MEG study available. Catalog: ” f”{sorted(catalog.keys())[:20]}… ” “Install neuralfetch correctly (pip install neuralfetch) and re-run.” ) print(f”→ Using study: {study_name}”) We dynamically import all submodules from NeuralFetch and NeuralSet to ensure that all available studies are properly registered. We seed the random number generator for reproducibility and inspect the study catalog to identify available MEG datasets. We then select an appropriate study to use as the foundation for our pipeline. Copy CodeCopiedUse a different Browser class CharCount(ext_mod.BaseStatic): event_types: tp.Literal[“Word”] = “Word” def get_static(self, event) -> torch.Tensor: return torch.tensor([float(len(event.text))], dtype=torch.float32) print(“nBuilding chain…”) chain = ns.Chain(steps=[ {“name”: study_name, “path”: str(ns.CACHE_FOLDER)}, {“name”: “QueryEvents”, “query”: “type in [‘Word’, ‘Meg’]”}, ]) events = chain.run() print(f” → {len(events)} events; types={sorted(events.type.unique().tolist())}”) print(f” → Words: {(events.type==’Word’).sum()} | ” f”timelines: {events.timeline.nunique()}”) print(“nSample words:”) print(events[events.type==’Word’][[“start”,”duration”,”text”,”timeline”]] .head(5).to_string(index=False)) print(“nBuilding segmenter…”) segmenter = ns.dataloader.Segmenter( extractors={ “meg”: {“name”: “MegExtractor”, “frequency”: 100.0}, “char_count”: CharCount(aggregation=”trigger”), }, trigger_query=”type == ‘Word'”, start=-0.2, duration=0.8, drop_incomplete=True, ) dataset = segmenter.apply(events) print(f” → SegmentDataset: {len(dataset)} segments”) s0 = dataset[0] print(f”nSingle item:n meg : {tuple(s0.data[‘meg’].shape)}”) print(f” char_count : {s0.data[‘char_count’].item()} ” f”(word: {s0.segments[0].trigger.text!r})”) We define a custom extractor that computes the character count of each word event, enabling us to create a supervised learning target. We build a processing chain to load and filter relevant events from the selected study. We then segment the MEG signals around word events and construct a dataset ready for modeling. Copy CodeCopiedUse a different Browser rng = np.random.RandomState(42) perm = rng.permutation(len(dataset)) n_tr, n_va = int(0.70*len(dataset)), int(0.15*len(dataset)) train_ds = dataset.select(perm[:n_tr]) val_ds = dataset.select(perm[n_tr:n_tr+n_va]) test_ds = dataset.select(perm[n_tr+n_va:]) print(f”nSplit | train={len(train_ds)} val={len(val_ds)} test={len(test_ds)}”) mk = lambda d, sh: DataLoader(d, batch_size=32, shuffle=sh, collate_fn=d.collate_fn, drop_last=False) train_loader, val_loader, test_loader = mk(train_ds, True), mk(val_ds, False), mk(test_ds, False) probe = next(iter(train_loader)) n_ch, n_t = probe.data[“meg”].shape[-2:] print(f” → batch[meg] shape: {tuple(probe.data[‘meg’].shape)}”) print(f” → batch[char] shape: {tuple(probe.data[‘char_count’].shape)}”) class MEGDecoder(nn.Module): def __init__(self, n_channels: int, mid: int = 64): super().__init__() self.spatial = nn.Conv1d(n_channels, mid, 1) self.bn0 = nn.BatchNorm1d(mid) self.temporal1 = nn.Conv1d(mid, mid, 7, padding=3) self.bn1 = nn.BatchNorm1d(mid) self.temporal2 = nn.Conv1d(mid, mid//2, 7, padding=3) self.bn2 = nn.BatchNorm1d(mid//2) self.pool = nn.AdaptiveAvgPool1d(1) self.head = nn.Linear(mid//2, 1) self.drop = nn.Dropout(0.3) def forward(self, x): x = F.gelu(self.bn0(self.spatial(x))) x = F.gelu(self.bn1(self.temporal1(x))) x = self.drop(x) x = F.gelu(self.bn2(self.temporal2(x))) return self.head(self.pool(x).squeeze(-1)).squeeze(-1) device = torch.device(“cuda” if torch.cuda.is_available() else “cpu”) model = MEGDecoder(n_channels=n_ch).to(device) print(f”nDevice: {device} | params: {sum(p.numel() for p in model.parameters()):,}”) train_targets = torch.cat([b.data[“char_count”].squeeze(-1) for b in train_loader]) y_mean, y_std = train_targets.mean().item(), train_targets.std().item() + 1e-6 print(f”Target μ={y_mean:.2f} σ={y_std:.2f}”) def prep(batch): x = batch.data[“meg”].to(device).float() y = batch.data[“char_count”].squeeze(-1).to(device).float() x = (x – x.mean(-1, keepdim=True)) / (x.std(-1, keepdim=True) + 1e-6) y = (y – y_mean) / y_std return x, y We split the dataset into training, validation, and test sets to ensure proper model evaluation. We create data loaders and inspect batch shapes to confirm correct data formatting. We then define a convolutional neural network and prepare normalized inputs and targets for stable training. Copy CodeCopiedUse a different Browser EPOCHS = 15 opt = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4) sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=EPOCHS) loss_fn = nn.MSELoss() hist = {“tr”: [], “va”: [], “r”: []} def pearson(a, b): a, b = a – a.mean(), b – b.mean() return (a*b).sum() / (a.norm()*b.norm() + 1e-8) print(“n” + “=”*64) print(f”{‘Epoch’:>5} | {‘train’:>9} | {‘val’:>9} | {‘val_r’:>7}”) print(“=”*64) for ep in range(EPOCHS): model.train(); tr = [] for batch in train_loader: x, y = prep(batch) loss = loss_fn(model(x), y) opt.zero_grad(); loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) opt.step(); tr.append(loss.item()) sched.step() model.eval(); va, P, T = [], [], [] with torch.no_grad(): for batch in val_loader: x, y = prep(batch); p = model(x) va.append(loss_fn(p, y).item()); P.append(p.cpu()); T.append(y.cpu()) P, T = torch.cat(P), torch.cat(T) r = pearson(P, T).item() hist[“tr”].append(np.mean(tr)); hist[“va”].append(np.mean(va)); hist[“r”].append(r) print(f”{ep+1:>5d} | {np.mean(tr):>9.4f} | {np.mean(va):>9.4f} | {r:>+7.3f}”) model.eval(); P, T = [], [] with torch.no_grad(): for batch in test_loader: x, y = prep(batch) P.append(model(x).cpu()); T.append(y.cpu()) P, T = torch.cat(P), torch.cat(T) test_r = pearson(P, T).item() test_mse = ((P – T) ** 2).mean().item() print(f”nTEST | Pearson r = {test_r:+.3f} MSE = {test_mse:.3f}”) print(f”(Synthetic-MEG signals are random by design — small/zero r is expected.)”) fig, ax = plt.subplots(1, 3, figsize=(15, 4))

In this tutorial, we explore the lambda/hermes-agent-reasoning-traces dataset to understand how agent-based models think, use tools, and generate responses across multi-turn conversations. We start by loading and inspecting the dataset, examining its structure, categories, and conversational format to get a clear idea of the available information. We then build simple parsers to extract key components such as reasoning traces, tool calls, and tool responses, allowing us to separate internal thinking from external actions. Also, we analyze patterns such as tool usage frequency, conversation length, and error rates to better understand agent behavior. We also create visualizations to highlight these trends and make the analysis more intuitive. Finally, we prepare the dataset for training by converting it into a model-friendly format, making it suitable for tasks like supervised fine-tuning. Copy CodeCopiedUse a different Browser !pip -q install -U datasets pandas matplotlib seaborn transformers accelerate trl import json, re, random, textwrap from collections import Counter, defaultdict import pandas as pd import numpy as np import matplotlib.pyplot as plt from datasets import load_dataset, concatenate_datasets random.seed(0) CONFIG = “kimi” ds = load_dataset(“lambda/hermes-agent-reasoning-traces”, CONFIG, split=”train”) print(ds) print(“Config:”, CONFIG, “| Fields:”, ds.column_names) print(“Categories:”, sorted(set(ds[“category”]))) COMPARE_BOTH = False if COMPARE_BOTH: ds_kimi = load_dataset(“lambda/hermes-agent-reasoning-traces”, “kimi”, split=”train”) ds_glm = load_dataset(“lambda/hermes-agent-reasoning-traces”, “glm-5.1″, split=”train”) ds_kimi = ds_kimi.add_column(“source”, [“kimi”] * len(ds_kimi)) ds_glm = ds_glm.add_column(“source”, [“glm-5.1”] * len(ds_glm)) ds = concatenate_datasets([ds_kimi, ds_glm]).shuffle(seed=0) print(“Combined:”, ds, “→ counts:”, Counter(ds[“source”])) sample = ds[0] print(“n=== Sample 0 ===”) print(“id :”, sample[“id”]) print(“category :”, sample[“category”], “/”, sample[“subcategory”]) print(“task :”, sample[“task”]) print(“turns :”, len(sample[“conversations”])) print(“system[0] :”, sample[“conversations”][0][“value”][:220], “…n”) We install all required libraries and import the necessary modules to set up our environment. We then load the lambda/hermes-agent-reasoning-traces dataset and inspect its structure, fields, and categories. We also optionally combine multiple dataset configurations and examine a sample to understand the conversational format. Copy CodeCopiedUse a different Browser THINK_RE = re.compile(r”<think>(.*?)</think>”, re.DOTALL) TOOL_CALL_RE = re.compile(r”<tool_call>s*({.*?})s*</tool_call>”, re.DOTALL) TOOL_RESP_RE = re.compile(r”<tool_response>s*(.*?)s*</tool_response>”, re.DOTALL) def parse_assistant(value: str) -> dict: thoughts = [t.strip() for t in THINK_RE.findall(value)] calls = [] for raw in TOOL_CALL_RE.findall(value): try: calls.append(json.loads(raw)) except json.JSONDecodeError: calls.append({“name”: “<malformed>”, “arguments”: {}}) final = TOOL_CALL_RE.sub(“”, THINK_RE.sub(“”, value)).strip() return {“thoughts”: thoughts, “tool_calls”: calls, “final”: final} def parse_tool(value: str): raw = TOOL_RESP_RE.search(value) if not raw: return {“raw”: value} body = raw.group(1) try: return json.loads(body) except: return {“raw”: body} first_gpt = next(t for t in sample[“conversations”] if t[“from”] == “gpt”) p = parse_assistant(first_gpt[“value”]) print(“Thought preview :”, (p[“thoughts”][0][:160] + “…”) if p[“thoughts”] else “(none)”) print(“Tool calls :”, [(c.get(“name”), list(c.get(“arguments”, {}).keys())) for c in p[“tool_calls”]]) We define regex-based parsers to extract reasoning traces, tool calls, and tool responses from the dataset. We process assistant messages to separate thoughts, actions, and final outputs in a structured way. We then test the parser on a sample conversation to verify that the extraction works correctly. Copy CodeCopiedUse a different Browser N = 3000 sub = ds.select(range(min(N, len(ds)))) tool_calls = Counter() parallel_widths = Counter() thoughts_per_turn = [] calls_per_traj = [] errors_per_traj = [] turns_per_traj = [] cat_counts = Counter() for ex in sub: cat_counts[ex[“category”]] += 1 n_calls = n_err = 0 turns_per_traj.append(len(ex[“conversations”])) for t in ex[“conversations”]: if t[“from”] == “gpt”: p = parse_assistant(t[“value”]) thoughts_per_turn.append(len(p[“thoughts”])) if p[“tool_calls”]: parallel_widths[len(p[“tool_calls”])] += 1 for c in p[“tool_calls”]: tool_calls[c.get(“name”, “<unknown>”)] += 1 n_calls += len(p[“tool_calls”]) elif t[“from”] == “tool”: r = parse_tool(t[“value”]) blob = json.dumps(r).lower() if “error” in blob or ‘”exit_code”: 1’ in blob or “traceback” in blob: n_err += 1 calls_per_traj.append(n_calls) errors_per_traj.append(n_err) print(f”nScanned {len(sub)} trajectories”) print(f”Avg turns/traj : {np.mean(turns_per_traj):.1f}”) print(f”Avg tool calls/traj : {np.mean(calls_per_traj):.1f}”) print(f”% with >=1 error : {100*np.mean([e>0 for e in errors_per_traj]):.1f}%”) print(f”% parallel turns : {100*sum(v for k,v in parallel_widths.items() if k>1)/max(1,sum(parallel_widths.values())):.1f}%”) print(“Top 10 tools :”, tool_calls.most_common(10)) fig, axes = plt.subplots(2, 2, figsize=(13, 9)) top = tool_calls.most_common(15) axes[0,0].barh([t for t,_ in top][::-1], [c for _,c in top][::-1], color=”teal”) axes[0,0].set_title(“Top 15 tools by call volume”) axes[0,0].set_xlabel(“calls”) ks = sorted(parallel_widths) axes[0,1].bar([str(k) for k in ks], [parallel_widths[k] for k in ks], color=”coral”) axes[0,1].set_title(“Tool-calls per assistant turn (parallel width)”) axes[0,1].set_xlabel(“# tool calls in one turn”); axes[0,1].set_ylabel(“count”) axes[0,1].set_yscale(“log”) axes[1,0].hist(turns_per_traj, bins=40, color=”steelblue”) axes[1,0].set_title(“Conversation length”); axes[1,0].set_xlabel(“turns”) cats, vals = zip(*cat_counts.most_common()) axes[1,1].pie(vals, labels=cats, autopct=”%1.0f%%”, startangle=90) axes[1,1].set_title(“Category distribution”) plt.tight_layout(); plt.show() We perform dataset-wide analytics to measure tool usage, conversation lengths, and error patterns. We aggregate statistics across multiple samples to understand overall agent behavior. We also create visualizations to highlight trends such as tool frequency, parallel calls, and category distribution. Copy CodeCopiedUse a different Browser def render_trace(ex, max_chars=350): print(f”n{‘=’*72}nTASK [{ex[‘category’]} / {ex[‘subcategory’]}]: {ex[‘task’]}n{‘=’*72}”) for t in ex[“conversations”]: role = t[“from”] if role == “system”: continue if role == “human”: print(f”n[USER]n{textwrap.shorten(t[‘value’], 600)}”) elif role == “gpt”: p = parse_assistant(t[“value”]) for th in p[“thoughts”]: print(f”n[THINK]n{textwrap.shorten(th, max_chars)}”) for c in p[“tool_calls”]: args = json.dumps(c.get(“arguments”, {}))[:200] print(f”[CALL] {c.get(‘name’)}({args})”) if p[“final”]: print(f”n[ANSWER]n{textwrap.shorten(p[‘final’], max_chars)}”) elif role == “tool”: print(f”[TOOL_RESPONSE] {textwrap.shorten(t[‘value’], 220)}”) print(“=”*72) idx = int(np.argmin(np.abs(np.array(turns_per_traj) – 10))) render_trace(sub[idx]) def get_tool_schemas(ex): try: return json.loads(ex[“tools”]) except: return [] schemas = get_tool_schemas(sample) print(f”nSample 0 has {len(schemas)} tools available”) for s in schemas[:3]: fn = s.get(“function”, {}) print(” -“, fn.get(“name”), “—”, (fn.get(“description”) or “”)[:80]) ROLE_MAP = {“system”: “system”, “human”: “user”, “gpt”: “assistant”, “tool”: “tool”} def to_openai_messages(conv): return [{“role”: ROLE_MAP[t[“from”]], “content”: t[“value”]} for t in conv] example_msgs = to_openai_messages(sample[“conversations”]) print(“nFirst 2 OpenAI messages:”) for m in example_msgs[:2]: print(” “, m[“role”], “→”, m[“content”][:120].replace(“n”, ” “), “…”) We build utilities to render full conversation traces in a readable format for deeper inspection. We also extract tool schemas and convert the dataset into OpenAI-style message format for compatibility with training pipelines. This helps us better understand both the structure of tools and how conversations can be standardized. Copy CodeCopiedUse a different Browser from transformers import AutoTokenizer TOK_ID = “Qwen/Qwen2.5-0.5B-Instruct” tok = AutoTokenizer.from_pretrained(TOK_ID) def build_masked(conv, tokenizer, max_len=2048): msgs = to_openai_messages(conv) for m in msgs: if m[“role”] == “tool”: m[“role”] = “user” m[“content”] = “[TOOL OUTPUT]n” + m[“content”] input_ids, labels = [], [] for m in msgs: text = tokenizer.apply_chat_template([m], tokenize=False, add_generation_prompt=False) ids = tokenizer.encode(text, add_special_tokens=False) input_ids.extend(ids) labels.extend(ids if m[“role”] == “assistant” else [-100] * len(ids)) return input_ids[:max_len], labels[:max_len] ids, lbls = build_masked(sample[“conversations”], tok) trainable = sum(1 for x in lbls if x != -100) print(f”nTokenized example: {len(ids)} tokens, {trainable} trainable ({100*trainable/len(ids):.1f}%)”) think_lens, call_lens, ans_lens = [], [], []

This past week delivered another gut punch for science in the US. This time, the target was the National Science Foundation—a federal agency that funds major research projects to the tune of around $9 billion. The foundation’s efforts were overseen by a board of 22 prominent scientists. On Friday last week, they were all fired. The NSF has been without a director since April 2025, when former director Sethuraman Panchanathan stepped down in the wake of DOGE-led funding cuts and mass firings. Trump’s nominee for the role is Jim O’Neill, an investor and longevity enthusiast who does not have a science background. It’s hard to predict exactly how things will shake out for science. But it’s not looking great. The NSF was established in 1950 to “promote the progress of science,” among other goals. It has served as a major source of support for research and education since then. In 2024, the agency spent $9.39 billion—a substantial figure but only 0.1% of all federal spending. Key decisions about how that money is spent have been made by the National Science Board. Each of the scientists who made up the board until last week was appointed by a US president to serve, at least initially, a six-year term. Those members were responsible for establishing NSF policies, authorizing major expenditures and providing oversight, says Keivan Stassun, a physicist and astronomer at Vanderbilt University who was appointed to the board in late 2022. A few years ago, the board was responsible for establishing a new “directorate” within the agency to channel funding to “technology, innovations and partnerships,” for example. The board also authorized funding for the US Extremely Large Telescope Program. “It’s a relatively small group with a tremendous amount of responsibility and authority,” says Stassun. He viewed his appointment as “a tremendous honor.” Then, last Friday, the email landed in his inbox. “It said: On behalf of President Trump, this letter is to notify you that your position as a member of the National Science Board is terminated effective immediately. Thank you for your service,” says Stassun. “It was deeply disappointing.” Still, Stassun wasn’t surprised, given the administration’s actions across federal science agencies over the past year. Since Donald Trump took office at the start of 2025, the NSF—along with many other federal agencies—has frozen, unfrozen, and terminated grants. “The board was not involved in any of those [terminations],” says Stassun. Members had no say in the firing of agency staff either, he says. Staff numbers are currently down 40%, he adds. In a 2026 budget request, the Trump administration sought to cut the NSF’s budget by around 57%. Last summer, NSF staffers wrote a letter of dissent arguing that such substantial cuts would “cripple American science.” The proposed cuts would have hit biological sciences, engineering, and STEM education particularly hard. Those cuts were rejected by Congress earlier this year. But grant terminations and firings are essentially allowing them to take effect regardless, says Stassun. “The funds that the White House has been dispersing to the agency … have been far less than what Congress intended,” he says. Many ambitious research projects are grinding to a halt as a result. “The Extremely Large Telescope Program appears to be dead in the water for now,” says Stassun. And the NSF arm dedicated to science education “has effectively zeroed out,” he says. But not all of them. While the administration’s 2027 budget request states that NSF will “close out” its directorate for social, behavioral, and economic sciences, it describes AI and quantum information science as key “frontier initiatives.” Biotechnology is described as a “focal point.”  When asked for comment, the NSF directed MIT Technology Review to the White House press office. The White House did not respond directly to questions about the firing of NSB members and said in a statement, “The National Science Foundation’s work continues uninterrupted.” Jim O’Neill, Trump’s current candidate for the position of NSF director, is certainly interested in biotechnology. Specifically, when I spoke to O’Neill in February, he told me that he supposes he is a Vitalist—a hardcore supporter of efforts to extend human longevity who believes that death is wrong. O’Neill was deputy secretary of the Department of Health and Human Services and acting director of the Centers for Disease Control and Prevention until a leadership shakeup a couple of months ago. But he isn’t a scientist. And that has some scientists worried. He has yet to be confirmed by the Senate for the role. In the meantime, the administration’s efforts are having a real impact on research. “We [NSB members] tried to stand for a continued investment in science, engineering, and technology, and in science education broadly,” says Stassun. “The administration will now be able to operate the agency the way that [it wants to, with] no governance body in the way.”

A new US-wide cell phone network marketed to Christians is set to launch next week. It blocks porn, which experts in network security say marks the first time a US cell plan has used network-level blocking for such content that can’t be turned off even by adult account owners. It’s also rolling out a filter on sexual content aimed at blocking material related to gender and trans issues, which will be optional but turned on by default across all plans. The network, which is currently being tested ahead of its May 5 launch date, will be run by Radiant Mobile, a newly launched mobile virtual network operator (MVNO). These operators don’t own cell towers but buy bandwidth from the big providers (in this case, T-Mobile) and sell to specific demographics (President Trump announced his own MVNO last year called Trump Mobile; CREDOMobile sends donations to progressive causes).  “We are going to create—and we think we have every right to do so—an environment that is Jesus-centric, that is void of pornography, void of LGBT, void of trans,” Radiant Mobile’s founder, Paul Fisher, told MIT Technology Review. A representative for T-Mobile did not comment on whether these content blocks violate any of its policies. In a statement, the representative added that T-Mobile does not have a direct relationship with Radiant Mobile but instead works through the MVNO manager CompaxDigital.  Fisher says he’s recruited a mix of Christian influencers to advertise the plan and has also done outreach to thousands of churches around the country, offering a way to have Radiant donate a portion of congregants’ $30-per-month subscription fee to their church. Fisher has ambitions to market it beyond the US in other countries with significant Christian populations, like South Korea and Mexico. At least one piece of Radiant’s pitch will sound familiar: the idea that the internet is awash in toxic sludge. It’s powered by content and algorithms that are making us more sad, hateful, and detached. A number of efforts aim to fix that, including contentious age verification laws and a coming wave of lawsuits alleging that social media companies knowingly got young users hooked on their platforms.  Fisher is pursuing the nuclear option. He says Radiant is working with the Israeli cybersecurity company Allot to block categories of content, such as material about violence or self-harm. Some categories are banned by default and cannot be allowed even for adult users.  This includes pornography. Chris Klimis, a minister in Orlando who was recruited to be the company’s chief operating officer, says part of the reason he got involved was to offer Christians a real way to “do something” about what he sees as a pornography crisis in the faith. He was appalled by a recent survey showing that 67% of pastors have a “personal history” with porn use. And he worries his six children will come across porn on their devices, even if only inadvertently. “We’ve got to figure out some way to close the door to the digital space,” he says. “That’s what we’re trying to do.” The technology to do this blocking is a blunt instrument: Allot groups website domains into more than a hundred categories, which include pornography but also violence, malware, gaming, and in Radiant Mobile’s case “sects,” which includes websites about Satanism. If one of its users tries to visit a website that belongs to a blocked category, the page won’t load. That’s harsher than app-based content blockers like Covenant Eyes, a Christian porn-quitting app that sends notifications to your friends or family if you slip up; those can be worked around or deleted. “Blocking in the network is certainly not new,” says David Choffnes, a computer science professor and executive director of Northeastern University’s Cybersecurity and Privacy Institute. Such blocking is the backbone of censorship efforts by authoritarian governments, for example. But there are more benign ways it’s used too. US telecoms block particular domains known to be spreading malware and offer optional network-level controls to block adult content on kids’ phones. What is new is a US cell plan instituting network-level blocks that can’t be removed, even by adults. The trouble is that most websites don’t fit neatly into one category, leaving Fisher with enormous and subjective control over which are allowed or banned. This is most apparent in his effort to block content related to gender identity. Anthony Re, a sales director at Allot, says the company does not have a category specific to gender but that “LGBT content” tends to fall into its sexuality category, which is described on Radiant Mobile’s website as “sites that provide information on sex, sex and teenagers, and sexual education, without pornographic content.” This category is blocked by default for all phones, a setting that can be changed by adult account owners.  But if a news site starts hosting enough gender-related content, Fisher might not just label it as “press,” which is allowed, but also “sexuality,” thus blocking the whole domain to any phone with that category blocked.  Fisher illustrates the subjectivity of such decisions with a recent example involving Yale University. Its general website, www.yale.edu, is categorized by Allot as education. “But they have a subsection of one of their websites that’s totally focused on, you know, trans equality,” Fisher says, referring to lgbtq.yale.edu. Because it’s a distinct domain, Radiant Mobile is able to place it in the sexuality category and block it.  Yale’s main website remains unblocked, for now. “If we see [the LGBTQ content] on the front pages consistently of Yale University, we’ll block them too,” Fisher says. Managing website block lists is a professional pivot for Fisher, who spent his career not in telecoms but in fashion; he was an agent for supermodels like Naomi Campbell and members of the Hilton and Getty families, and he later hosted a reality show in which he found people in rehab facilities and homeless shelters and tried to turn them into models. He ultimately left the industry and now says he regrets the role he