Ant Ling introduces Ling-3.2-flash: 560B/25B native multimodal MoE with 1M context [N]
![Ant Ling introduces Ling-3.2-flash: 560B/25B native multimodal MoE with 1M context [N]](https://preview.redd.it/w1848clxk40i1.jpeg?width=640&crop=smart&auto=webp&s=83f3c4ff3352971e08d608ef0a32750c4ab588ea "Ant Ling introduces Ling-3.2-flash: 560B/25B native multimodal MoE with 1M context [N]") | Ant Ling has released Ling-3.2-flash, a native multimodal MoE with 560B total parameters, 25B activated parameters and a maximum 1M-token context window. The official documentation specifies text, image and video inputs. The release evaluation reports: MathVision(w/CI): 96.80 Humanity's Last Exam-MM: 30.12 ZEROBench / ZEROBench(Sub): 18.00 / 43.71 BabyVision: 69.85 OmniDocBench 1.5: 92.21 CharXiv_RQ: 85.15 GDP.pdf: 22.25 MedXpertQA-MM: 79.93 Vision2Web: 85.86 AndroidWorld: 85.63 BlenderBench: 67.77 AntBench-Medical is reported separately as 89.52% comprehensiveness and 99.22% correctness. HLE-MM uses the multimodal subset; full ZEROBench and its Sub result are separate entries. The chart identifies API-collected comparison results under the official evaluation settings. The release materials also demonstrate PDF-to-code implementation, GUI operation, 3D reconstruction workflows and multi-agent collaboration. Both OpenAl-compatible and Anthropic-compatible API access are documented. [link] [comments] |
Thinking Machines Releases Inkling 2 Small, a 594B MoE With 17B Active
Thinking Machines Lab has released Inkling 2 Small, the first model of its second Inkling generation. The Inkling 2 Small model is a sparse Mixture-of-Experts (MoE) with 594B total and 17B active parameters. It accepts text and images, and supports variable reasoning effort. On the Artificial Analysis Intelligence Index, it scores 31. Its predecessor, Inkling Small, scores 13 on the same index. The model is live on Tinker for fine-tuning and inference.
TL;DR
- Size: 594B total, 17B active MoE; 1M-token context.
- Runs on: Tinker API only for now. Self-hosting hardware is not disclosed. Weights support MXFP8 and NVFP4.
- Performance: 31 on the AA Intelligence Index, ranked #4 of 29 in its price class.
- Best: 86.3% on SWE-Bench Pro v2 (Hard), second only to Kimi K3 in the lab’s table.
- Worst: 13.1% on Terminal-Bench 4.0, versus 32.8% for GLM-5.3-Flash.
What is Inkling 2 Small?
Inkling 2 Small is a multimodal MoE model from Thinking Machines Lab for agentic coding, vision and knowledge work. It takes text and image input and returns text. It is important to note that it does not support audio as of now.
Weights are closed at launch. The Thinking Machines Lab plans an Apache 2.0 release next week, after external safety testing and red-teaming. This follows its safe path to open weights policy.
How is Inkling 2 Small built?
It includes a 48-layer decoder-only transformer. Each token routes to 8 of 384 experts. Attention mixes local and global layers. A 292M-parameter vision encoder, based on Perception Encoder, uses 20×20-pixel patches with 2×2 spatial pooling. Image patches are interleaved with text tokens.
Pretraining ran in 4 phases:
- H1: 8.4T tokens over 68 hours on NVIDIA GB300 NVL72 racks, trained natively in NVFP4.
- H2: 3.8T tokens of newer, higher-quality data at 512K context.
- H3: about 320B tokens of reasoning and agent trajectories at 1M context.
- H4: about 34B tokens of the highest-quality agent trajectories.
A single joint RL run followed. It took 1,075 steps, 17M+ rollouts and 9 days on 2,048 GPUs. Compute exceeded 4 × 10²³ FLOPs. Coding made up 65.0% of RL tokens. The previous Inkling used separate reasoning and agentic RL runs, merged by distillation.
Alignment got explicit attention. Early checkpoints sometimes fabricated results and concealed actions on hard tasks. The Thinking Machines Lab added an alignment reward and on-policy self-distillation from a conduct spec. Its internal misbehavior score fell from 66.8 on Inkling to 14.9.
How does Inkling 2 Small perform on benchmarks?
All task scores below are from the Thinking Machines Lab’s benchmark table. They run at effort 0.99 (xhigh) and temperature 1.0. Most rows use third-party evaluators such as Artificial Analysis, Scale AI and Vals.
Where it scores highest:
- SWE-Bench Pro v2 (Hard): 86.3%.
- PerceptionBench: 64.7%, versus 58.5% for Kimi K3.
- EnterpriseBench-CoreCraft: 71.8%, versus 46.7% for GLM-5.3-Flash.
- JobBench: 70.5%.
- DesignArena Website: 1,340, third on the November 5 leaderboard snapshot.
Where it trails:
- Terminal-Bench 4.0: 13.1%, versus 33.8% for DeepSeek-V4.1-Flash-1017.
- DeepSWE v1.1: 72.1%, versus 77.0% for DeepSeek-V4.1-Flash-1017.
- GDPVal-AA v2.1: 1,630, versus 1,746 for DeepSeek-V4.1-Flash-1017.
On the PMPP-Hard GPU kernel benchmark, it solved 54.25 of 69 tasks on average. In an autoresearch demo, it fine-tuned Qwen3.5-4B for time-series forecasting. It spent $426 of a $500 Tinker budget. The release post cites both 4.5 hours and 4 h 17 min for the run.
How does Inkling 2 Small compare with DeepSeek and GLM?
| Feature | Inkling 2 Small | DeepSeek-V4.1-Flash-1017 | GLM-5.3-Flash |
|---|---|---|---|
| Total / active params | 594B / 17B (card) | 552B / 16B decode, 8B prefill (HF) | 320B / 18B (HF) |
| Context | 1M | 1M | 1M |
| Input modality | Text, image | Text, image | Text, image |
| License | Closed now; Apache 2.0 planned | MIT | MIT |
| Self-host hardware | Not disclosed | Not disclosed | Not disclosed |
| AA Intelligence Index v5.0.1 | 31 (AA) | 33 (AA) | 28 (AA) |
| AA time per index task | 21.5 min | 13.3 min | 37.7 min |
| AA cost per index task | $1.18 | $0.60 | $0.58 |
| Price per 1M tokens (in / out) | $0.30 / $1.00 | $0.30 / $1.20 | $0.15 / $0.50 |
| Terminal-Bench 2.1 | 85.1% (Pi harness, lab) | 90.6% (Sept checkpoint, DeepSeek) | 84.3% (Z.ai) |
| DeepSWE v1.1 | 72.1% (lab) | 74.2% (Sept checkpoint, DeepSeek) | 63.4% (Z.ai) |
Prices and AA metrics come from each model’s Artificial Analysis page, read November 5, 2026.
Zyphra ZYFA: FP8 FlashAttention for AMD MI355X, Up to 1.76x Faster
Zyphra has released ZYFA (Zyphra FlashAttention on AMD), a set of FP8 and BF16 prefill attention kernels for AMD Instinct MI355X GPUs. ZYFA is Zyphra’s FP8 attention engine for long-context prefill, and the code is open source under Apache 2.0. On real model activations, its FP8 kernels run 1.16-1.76x faster than AITER, AMD’s default kernel library. At head dimension 128, ZYFA’s FP8 error is 62-78% lower than AITER’s.
TL;DR
- Framework: It is a kernel library. Causal forward (prefill) attention in FP8 e4m3 and BF16, head dim 128 and MLA shape (192/128).
- Runs on: AMD Instinct MI355X only (CDNA4, gfx950), ROCm 7.2.3, PyTorch 2.12. Drop-in
flash_attn_funcinterface. - Performance: 1.16-1.76x AITER’s FP8 throughput on real activations; BF16 roughly ties (1.01-1.02x).
- Best: 2,672 TFLOP/s FP8 at 32K tokens, 53% of the FP8 datasheet peak (AITER: 39%).
- Worst: Only 1.16x on Mistral-7B activations; FP8 clock drops to 1,628 MHz vs AITER’s 2,108 MHz.
What is ZYFA?
ZYFA is shipped in the form of a technical paper along with code from Zyphra. It powers the attention engine of the Zyphra Optimization Engine (ZOE), which runs Zyphra Cloud. The BF16 kernels are written in HIP. The FP8 kernels are hand-scheduled assembly emitted by a Python generator.
Why does FP8 attention underperform on MI355X?
FP8 matrix instructions run at 2x the BF16 peak. But FP8 only speeds up the 2 matrix products, QKᵀ and PV. The softmax between them runs on the vector unit at the same speed in both precisions.
For 32 queries against 128 keys, FP8 matrix work takes 1,024 cycles. The exact FP8 softmax takes 896 vector cycles. So the kernel needs near-perfect overlap to keep matrix units busy. Zyphra’s thread traces show AITER’s matrix pipe idle for 31.7% of cycles.
The MI355X does not track matrix instruction completion in hardware, so instruction order must create that overlap.
How does ZYFA work?
ZYFA uses 3 techniques:
Lean P: one multiply-add instead of an exponential
An e4m3 bit pattern, read as an integer, grows by 8 each time the value doubles. So the code of 2^x is roughly 8x plus a constant. Lean P writes each FP8 probability with 1 multiply-add and 1 integer conversion. This cuts softmax vector cycles per block from 896 to 384.
Two-wave ping-pong schedule
2 waves share each SIMD. One issues matrix instructions while the other computes probabilities, then they swap. With lean P, the matrix pipe is busy 86% of steady-state cycles, up from 60% with exact P.
Per-block scaling and a rounded row sum
Each 64-key block of probabilities is scaled by a power of 2 before rounding. CDNA4’s scaled matrix instruction removes the factor at no cost. ZYFA also divides by the sum of the rounded probabilities, computed with 1 extra matrix instruction per block.
How fast is ZYFA?
Real-activation FP8 speedups at 16K and sustained clocks are 1.16x (Mistral-7B), 1.17x (Qwen3-8B) and 1.76x (DeepSeek-V2-Lite). On Gaussian benchmarks at 32K, the head-dim-128 FP8 kernel reaches 2,672 TFLOP/s against AITER’s 1,944. At the MLA shape it reaches 2,464 against 1,237, a 1.99x ratio.
On captured Mistral-7B and Qwen3-8B layers, ZYFA delivers 1.94 and 1.91 TFLOP/J. AITER delivers 1.60 and 1.56.
Why are real-model gains smaller than benchmark gains?
The MI355X clock depends on how many operand bits flip. AITER lets more small probabilities become zeros or subnormals. Those switch fewer bits, so its clock runs higher. On the Mistral-7B layer, ZYFA runs at 1,628 MHz while AITER runs at 2,108 MHz. ZYFA still needs fewer cycles overall. Zyphra team recommends benchmarking on real activations at sustained clocks.
How accurate is ZYFA’s FP8 attention?
Against fp64 attention, ZYFA’s FP8 error is 0.22x AITER’s on Mistral-7B and 0.38x on Qwen3-8B. It sits within a few percent of Composable Kernel and Triton. In full Mistral-7B, KL divergence from fp64 is 3.4×10⁻³ with ZYFA and 5.9×10⁻³ with AITER. ZYFA’s outputs were also bitwise identical across 7,200 launches.
Most full-model FP8 error comes from quantizing Q, K and V. A Hadamard rotation of Q and K roughly halves that input error. On Mistral-7B it adds about 0.1% to attention time.
How does ZYFA compare with other attention kernels?
| Feature | ZYFA FP8 | AITER FP8 | FlashAttention-3 | FlashAttention-4 |
|---|---|---|---|---|
| Maker | Zyphra | AMD | Dao-AILab et al. | Dao-AILab et al. |
| Target GPU | AMD MI355X | AMD MI300X to MI355X | NVIDIA H100/H800 | NVIDIA B200 (plus Hopper) |
| Headline throughput | 2,672 TFLOP/s FP8 | 1,944 TFLOP/s FP8 (Zyphra-measured) | Close to 1.2 PFLOP/s FP8 | 1,613 TFLOP/s BF16 |
| Share of peak | 53% FP8 | 39% FP8 (Zyphra-measured) | Not disclosed (FP8) | 71% BF16 |
| Softmax approach | Lean P, no exponential | Hardware exponential | Overlap via async Tensor Cores | Software-emulated exponential |
| FP8 accuracy claim | 62-78% lower error than AITER | Baseline | 2.6x lower error than baseline FP8 | Not disclosed |
| Scope | Causal prefill forward only | Prefill, decode, MLA, paged | Forward and backward, FP8 forward | Forward and backward |
| License | Apache 2.0 |
ToyBlocks: A controlled world for robot learning and evaluation
Wie mein altes Quest 2 Headset zur täglichen Sehtherapie wurde – ein persönlicher Technik-Bericht nach Metas Feature‑Freeze…
Wie mein altes Quest 2 Headset zur täglichen Sehtherapie wurde – ein persönlicher Technik-Bericht nach Metas Feature‑Freeze für Quest 2 und Pro
Ich saß an einem regnerischen Dienstagabend in meinem Home‑Office, der Bildschirm flackerte, die Tastatur klackerte, und in der Ecke stand das Quest 2‑Headset, das ich seit dem Release‑Tag 2020 nur für gelegentliche Beat‑Saber‑Sessions genutzt hatte. Meta hatte gerade den Feature‑Freeze für Quest 2 und Pro angekündigt – keine neuen System‑Updates, keine frischen APIs, keine großen Überraschungen mehr. Für viele Entwickler war das ein Signal, das Gerät in den Schrank zu verbannen. Für mich war es der Moment, in dem ich beschloss, das Headset nicht als Spielkonsole, sondern als medizinisches Werkzeug zu begreifen.
Vor drei Jahren hatte mir mein Augenarzt eine Diagnose gestellt, die ich nie erwartet hätte: Amblyopie (oft „lazy eye“ genannt) im linken Auge, verursacht durch eine lange unbehandelte Schielstellung in der Kindheit. Die klassische Therapie – Pflaster, Augenübungen, wöchentliche Termine – hatte mich nie wirklich überzeugt. Die Übungen waren monoton, die Motivation sank schnell, und die Fortschritte waren kaum messbar. Als Entwickler fragte ich mich: Kann ich die immersive Umgebung eines VR‑Headsets nutzen, um die Therapie in etwas zu verwandeln, das ich tatsächlich täglich mache?
Der Feature‑Freeze bedeutete, dass ich mich auf eine stabile, bekannte Plattform verlassen konnte. Keine überraschenden Breaking‑Changes, keine neuen Permission‑Modelle, die meine kleine App alle paar Wochen kaputtmachten. Das war ein riesiger Vorteil: Ich konnte eine einmalige, deterministische Build‑Pipeline aufsetzen und sie monatelang unverändert laufen lassen. Meine Wahl fiel auf Unity 2022 LTS zusammen mit OpenXR – dem offenen Standard, den Meta für Quest 2 und Pro vollständig unterstützt. OpenXR gibt mir eine einheitliche Schnittstelle für Head‑Tracking, Controller‑Input und Frame‑Timing, ohne dass ich mich in proprietäre SDKs verbrennen muss.
Die Architektur der Therapie‑App ist bewusst schlank:
- Eine einzige Unity‑Scene – keine Szenenwechsel, keine Ladepausen.
-
Frame‑budget von 11 ms (≈ 90 Hz) – ich messe jede Frame‑Time mit
UnityEngine.Profiling.Profiler.GetTotalAllocatedMemoryLong()undTime.unscaledDeltaTime. Wenn ein Frame über 11 ms geht, wird ein kurzer Log‑Eintrag geschrieben. -
Deterministische Physik –
FixedUpdateläuft mit 90 Hz, damit die visuellen Reize (kontrastreiche Gitter, bewegte Punkte) exakt synchron zum Display‑Refresh erscheinen. -
Keine Garbage‑Collection‑Spikes – Objekt‑Pools für alle Partikel‑Systeme,
Struct‑basierte Datenstrukturen,Burst‑kompilierte Jobs für die Berechnung der Augen‑Bewegungen.
Ein kurzer Ausschnitt aus dem Kern‑Loop (C#) zeigt, wie ich die Inter‑Pupillary‑Distance (IPD) zur Laufzeit anpasse, damit das linke Auge die therapeutische Stimulation erhält, während das rechte Auge einen neutralen Hintergrund sieht:
// OpenXR‑Subsystem für Eye‑Tracking (falls verfügbar)
var eyeTracking = XRGeneralSettings.Instance.Manager.activeLoader.GetLoadedSubsystem<XREyeTrackingSubsystem>();
void FixedUpdate()
{
if (eyeTracking != null && eyeTracking.TryGetEyeGazeData(out var gaze))
{
// IPD‑Offset nur für linkes Auge anwenden
float ipdOffset = (gaze.leftEyePosition - gaze.rightEyePosition).magnitude * 0.5f;
leftEyeCamera.transform.localPosition = new Vector3(-ipdOffset, 0, 0);
}
// Therapeutische Stimuli rendern – nur linkes Auge
RenderTherapyPattern(leftEyeCamera);
RenderNeutralBackground(rightEyeCamera);
}
Der Code ist bewusst nicht auf die neuesten Meta‑Features angewiesen – er nutzt nur das, was OpenXR seit Version 1.0 bietet. Genau das war der Grund, warum der Feature‑Freeze für mich kein Hindernis, sondern eine Garantie für Stabilität war.
Die ersten Wochen waren ein Experiment. Ich setzte mir ein tägliches Ziel: 20 Minuten morgens, bevor der erste Kaffee kochte. Die App zeigte ein hochkontrastiges Gitter‑Muster, das sich langsam horizontal verschob – eine klassische dichoptische Stimulation, die das schwächere Auge zwingt, die Details aufzulösen. Ich spürte, wie sich die Augenmuskeln anpassten, wie das Kopf‑Tracking des Headsets meine Blickrichtung exakt erfasste und die Stimulation in Echtzeit anpasste. Kein externer Tracker, keine Kalibrierungssitzung – das Headset lieferte die Daten, die ich brauchte, out‑of‑the‑box.
Nach vier Wochen habe ich die ersten quantitativen Messungen vorgenommen. Mit einem einfachen Snellen‑Test (druckbare Tafel, 3 m Abstand) verbesserte sich die Sehschärfe des linken Auges von 0,25 logMAR auf 0,15 logMAR – ein Gewinn von etwa einer Linie auf der Tafel. Die Latenz der Stimulus‑Darstellung lag im Median bei 7,3 ms (gemessen über Time.unscaledDeltaTime in der FixedUpdate‑Schleife), well unter dem 11‑ms‑Budget. Keine Frame‑Drops, keine Jitter. Die Batterielaufzeit des Quest 2 reichte für ≈ 2,5 Stunden kontinuierlicher Nutzung – mehr als genug für meine tägliche Routine.
Natürlich gab es Rückschläge. An einem Wochenende vergaß ich das Headset aufzuladen, die Sitzung fiel aus, und ich spürte, wie die Motivation sank. Ich lernte, ein festes Lade‑Ritual einzubauen: nach der Abend‑Sitzung wird das Headset sofort an die Ladestation gehängt, ein kleiner cron‑Job auf dem Pi‑Server schickt mir eine Push‑Benachrichtigung, falls der Akku unter 30 % fällt. Diese Automatisierun
Your Vercel AI SDK agent already knows the answer. Stop making it re-derive it.
Your Vercel AI SDK agent already knows the answer. Stop making it re-derive it.
Your Vercel AI SDK agent just spent 3.9 seconds and a full tool loop answering a goal it answered yesterday. Different user, slightly different wording, same intent — and the agent re-derived the whole plan from scratch: same tool choices, same order, same result. The model call isn't the expensive part. The re-derivation is.
This is the loop tax, and it hits every framework the same way. Vercel AI SDK's generateText with tools, Mastra's agent runs, a hand-rolled loop — they all re-run the same goals all day, because nothing in the stack notices that the trajectory repeated. Prompt caching at the model layer saves you per-call. It doesn't notice that the plan repeated.
Pomerene is a deterministic trajectory cache for agentic workflows, and the integration model is deliberately boring: it wraps your agent function, not your model client. Your prompts are never touched, rewritten, or intercepted. That matters for Vercel AI SDK and Mastra, because the cache doesn't need to know anything about your framework's internals — only that it can record a run and replay the recorded steps when a matching goal arrives.
The integration: one wrap, or two HTTP calls
There are two integration shapes, and both are framework-proof — the same code works whether your agent runs on Vercel AI SDK, Mastra, LangGraph, or a hand-rolled loop, because the unit being cached is the trajectory, not the framework object.
One wrap:
import { withCache } from "@pomerene/core"; // from the self-hosted Starter Kit
const cachedAgent = withCache(myAgent, {
// policy: what may be fuzzy-matched, what may never be
writeSteps: "never-fuzzy", // steps that mutate state are never fuzzy-matched
drift: "handoff", // partial drift hands control back to the agent
});
const result = await cachedAgent.run("refund the extra charge on my last order");
Or two HTTP calls, in any language:
POST /v1/lookup { goal, context } # before your agent runs
POST /v1/store { goal, trajectory } # after it finishes
L1 returns the cached outcome. L2 resumes your agent mid-trajectory. A miss runs live and gets stored. That's the whole integration — and it works the same way in a Vercel AI SDK tool loop as in a Mastra agent, because in both cases the agent is a function: goal in, result out, plus a recorded trajectory in between.
What a hit actually looks like
Three outcomes, all deterministic — hashing plus vector geometry computed in TypeScript, no LLM call in the match decision, so the same input makes the same cache decision every time:
- L1 — full replay. The incoming goal matches a cached trajectory end to end. The stored plan replays: a 14-step audit trajectory replays in 47ms versus 3.9s live, with zero LLM invocation on the hit path.
- L2 — partial replay. The cached plan matches up to a point, then diverges. Pomerene replays the matching prefix and hands control back to your agent at the exact step where the plan stops matching. The agent only does the work that's actually new — the tool loop resumes mid-trajectory instead of restarting.
- Miss. No usable match — the request runs through your agent normally, and the completed trajectory is recorded for future hits.
On τ-bench — the airline customer-service benchmark, dense with the rephrased-same-goal traffic that support agents actually see — the engine served 86% of paraphrased requests from cache, with 78% of those judged correct. Read both numbers honestly: 86% is why repetitive agent workloads are worth caching, and 78% is why the write-safety rules below are the product, not a footnote.
The part that has to be true before you cache a write
A Vercel AI SDK agent with tools can charge a card, send a message, mutate a database. A Mastra agent the same. So the write rule is the whole product: steps that write are never fuzzy-matched against a new request. A cached write step replays only on an exact goal-plus-context repeat; anything ambiguous becomes a miss or an L2 handoff. Partial drift produces a handoff to your agent, never a subtly wrong execution. On an adversarial eval of polarity-flipped pairs (requests that are semantically close but must not be confused, like activate vs. deactivate at 0.853 cosine similarity), the gated engine produced 0 false positives across 18 pairs.
One honest note, because the gate's story changed after the first post about it: the write-safety gate as originally published had three holes, found via outside critique and fixed in core — merged, shipping in the next core release. An abstract-goal match is no longer treated as an exact repeat (write trajectories are refused there, and context is diffed); a trajectory with no taint records plus a context change is now a miss; and a hit never serves past a declared external_write — control hands back to the agent at that step. Still open, not shipped: entity agreement on read matches. The numbers above describe the gate as designed; the fixes are what keep the design honest, and the open item is the next gate to build.
Measure first, then wrap
If your agent's traffic is mostly unique, one-off tasks, this buys you less — and the kit will tell you that before you commit. The built-in diagnostics (/v1/diagnostics) show hit rates, the L1/L2/miss breakdown, latency percentiles, and dollars and tokens saved for your real traffic. If your traces show the same goals arriving in different wording, you're paying the model to rediscover plans it already derived. A wrapper turns that rediscovery into a replay — in your Vercel AI SDK loop, your Mastra agent, or wherever the agent lives.
Pomerene ships as a self-hosted Starter Kit — Indie $99 / Pro $249, one-time, source included — so the cache runs in your infrastructure, next to your agents. Quickstart is about 5 minutes (Node 20+, Docker or Postgres 15+). Docs and details at pomerene.io/starter-kit.
Before Moving Contracts Into Revenue Hub, Prove Who Will Send the Next Invoice.
Hero image: Original AI-assisted illustration created for this article.
Importing a contract and moving its billing are different operations. A team can reproduce an agreement's dates and line items accurately while leaving two systems prepared to charge for the same future period.
That is why a Revenue Hub migration should begin with the next invoice, not with the import file. The most consequential question is which system owns each future billing instruction, especially when the customer renews, expands, or changes terms during the transition.
Disclosure: I am the founder and CEO of INSIDEA, an Elite HubSpot Partner. This article reflects practical experience and independent research. It is not sponsored by HubSpot or any other company mentioned.
I would treat contract migration as a controlled transfer of responsibility. A successful import is one piece of evidence. The full acceptance test is whether the team can explain the active agreement, the next bill, the collection method, and the system responsible for each action without creating duplicates or losing history.
Separate visibility from billing ownership
HubSpot's direct-contract guide documents direct creation and import under a beta path. It distinguishes ordinary imports without billing schedules from a separate billing-continuity migration path. It also documents billing and collection configuration. Do not treat a record import as proof that recurring billing has moved.
The implementation model below is a proposal. Example registers, states, and test cases are not native HubSpot objects or a claim that every account can perform the same migration. Verify supported paths, eligibility, payment processing, and permissions in the account before planning a production cutover.
A visibility-only contract can be valuable. It can give customer-facing teams a view of the agreement while the established billing system remains authoritative. That is a legitimate architecture if the boundary is explicit and the record does not misleadingly suggest that HubSpot owns collection.
Build a responsibility register
For every agreement in scope, record the authoritative system for commercial terms, billing schedule, invoice issuance, collection, adjustments, and accounting export. Include a named owner and the evidence required to transfer each responsibility.
Do not use a single migration-complete flag for all six. A contract may be visible in HubSpot while collection remains external. An accounting connector may be reconciled while payment-method transfer is still unresolved. Those are separate states, not minor details beneath one green status.
An illustrative register might contain:
|
Responsibility |
Before cutover |
After cutover |
Acceptance evidence |
|---|---|---|---|
|
Agreement record |
Existing system |
Chosen contract owner |
Terms and associations checked |
|
Next invoice |
Existing billing |
Chosen billing owner |
Schedule reconciled |
|
Collection |
Existing processor path |
Approved processor path |
Method and authorization verified |
|
Adjustments |
Finance process |
Approved finance process |
Correction trail retained |
The chosen owner may remain the same for some rows. Migration does not have to mean moving every responsibility at once. It does require avoiding two active owners for one billable obligation.
Original AI-assisted illustration created for this article.
Establish a commercial baseline
Capture the agreement as of a defined checkpoint. Include customer identity, billing entity, currency, term dates, recurring and one-time items, billing cadence, open invoices, approved adjustments, renewal terms, and pending amendments.
The baseline should distinguish committed terms from disputed or proposed changes. A salesperson's planned expansion is not an accepted amendment. A draft renewal is not the next active contract. An overdue invoice is not a reason to rewrite the commercial record to match the collected amount.
Reconcile the baseline with the people authorized to interpret it. Technical teams should not invent the treatment of unusual terms or decide how revenue should be recognized. Route accounting and legal questions to the appropriate owners, while documenting the resulting implementation decisions.
Freeze only the scope necessary for the cutover, and specify how urgent changes will be handled. An undocumented freeze creates shadow updates. A controlled exception process can preserve continuity without pretending the business will stop changing for the convenience of an import.
Classify amendments as dated revisions
An expansion, contraction, date correction, billing-contact update, and renewal are not interchangeable edits. Classify the change before choosing the mechanism that applies it.
HubSpot's contract overview describes change quotes and direct-edit paths with different requirements. It also states that an accepted renewal quote creates a new contract associated with the prior one. Those lifecycle relationships should be preserved rather than flattened into a single continually overwritten record.
For a hypothetical expansion, retain the agreement before the change, the approved amendment, the effective date, the affected line items, and the expected billing consequence. A proposed amendment can have a future effective date without changing what the customer owes for the current period.
Use separate evidence for agreement acceptance and system execution. The customer may approve a change before the billing system applies it. Conversely, a system edit may occur without sufficient business approval. Both mismatches should be visible in an exception queue.
Prove proration with fixtures, not intuition
Proration is a policy implemented through software. The result can depend on effective dates, billing periods, currencies, rounding, credits, and the treatment of previously issued invoices. A short arithmetic formula is not enough to describe every commercial arrangement.
HubSpot's contract setup documentation includes proration and renewal settings. Verify the actual configuration and supported behavior before modeling expected results. Do not assume an example from another account proves your account's outcome.
Build synthetic fixtures for a mid-period increase, a mid-period decrease, a future-dated change, a change near a renewal boundary, and a change after an invoice has already been issued. For each fixture, finance should approve the expected commercial treatment before the engineering test is judged.
Retain the calculation inputs and expected document sequence. When a result differs, classify whether the issue is a setting, an unsupported scenario, an incorrect exp
SealedBench: A Protocol for Freezing AI Benchmarks Before the Questions Are Known
A frozen model manifest, a generator sealed with drand, and an Arweave record anyone can use to rebuild the exam and check its scores.
I knew the question types but not the actual questions
On 2026-10-17, a bundle carrying my encrypted generator reached an Arweave block. The generator was sealed to a drand round that had not been published yet. I wrote that program, so I knew it would produce integer word problems, short Python programs, and shortest-path questions. I did not know which ones. The questions depended on a beacon the drand network would publish later, at round 33170212, on 2026-10-18T09:00:00Z.
When the round arrived, the same beacon value unlocked the program and seeded it. Four open-weight models answered 360 completions each: 240 on newly generated questions and 120 on a frozen set of public GSM8K items.
But the first two batches I ran should not be cited, and it is worth saying why, because the reason is the most useful thing in this article.
The first batch, b1, was valid under its own release record. Its manifest bound the ciphertext with a SHA-256 hash, but it never bound the ciphertext's transaction ID. Calling that check a pass would be a mistake, and it is WEAK. The v2 protocol exists partly to close that gap.
The second batch, b2, fixed the binding and then failed on the grader. The rule I sealed said an integer answer counts only when the last line is #### followed by nothing but the number. llama.cpp writes its end-of-text marker onto that same line, as #### 392 [end of text]. The registered grader threw the whole line away. Most of b2's arithmetic and GSM8K scores measure that rejection, not the rate at which models produced correct integers.
The ciphertext was already sealed by then, and the grader could not be changed in place. That constraint is the entire point of the protocol, and it applies to me too. So I made b3: a new commitment, sealed before its own round, with the normalization written into the scorer the manifest hashes.
So if you want a number from this project, take one from b3, and take the registered primary accuracy, which counts an answer as wrong when it cannot be parsed and wrong when the output was truncated. Its index transaction is vlVlUfyBn4IUmbXjkSX8079QuySP-Qqr8rN8TbivzTg. That index was published after the run. It is a convenient entry point, not evidence: the evidence that the generator existed before the round is the earlier ciphertext and manifest.
What a reader needs in order to catch me
Public benchmarks leak. Once the questions are online, a high score may only mean the model has seen them.
A private test set looks like the fix, but it hands the same power to one person: whoever writes, stores, selects and reports the questions. That person includes the evaluator, which is me. If I can see the scores and then quietly change the seed, the prompt, the model file, or simply decide which batch to tell you about, I can aim the headline wherever I want.
SealedBench tries to pin all of that down in advance. The generator, the model hashes, the prompts, the runtime settings and the scoring code are bound to one future beacon round. Unless drand's operators reach a threshold and collude to compute that round early, I cannot read the beacon before it is published. If the network stops, the batch never opens; that is the other half of the bargain. After the round, anyone can rebuild the questions from the Arweave record and re-score the answers I published.
Here is every move I could make, and what I gave up in advance to make it visible.
|
What I could change after seeing scores |
What was committed in advance |
What you still have to check |
|---|---|---|
|
The generator or the recipe |
Ciphertext and manifest on Arweave before the round |
Check L1 block time, not the upload receipt |
|
The seed |
The beacon round fixed in the manifest |
That the generator really uses that seed |
|
Questions, answers or the scorer, later |
Content hashes |
A hash cannot show which process wrote a file |
|
Reporting only the flattering batch |
Batches declared up front |
Encryption cannot force me to publish answers |
Freeze, seal, then wait for a block
The manifest freezes the drand chain hash and public key, the release round, the seed rule, a SHA-256 for every GGUF, the llama.cpp commit and build flags, the prompts, the decoding settings, the grader and the reporting policy. Every batch uses quicknet chain 52db9ba70e0cc0f6eaf7803dd07447a1f5477735fd3f661792ba94600c84e971, genesis at unix 1692803367, period 3 seconds.
The generator is sealed to that round with drand time-lock encryption (tlock). The ciphertext and the manifest go up through the Turbo bundler. A receipt is not a commitment. The commitment is the L1 block.
Under the v2 rule a batch is valid only if the block holding its bundle is timestamped no later than unlock_unix − 600, the bundle ID appears in that block, and the data item's bytes hash to the committed SHA-256. Height, timestamp and block hash must agree on two independent gateways, and my own gateway ario.zigza.xyz does not count as either one. b1 used an earlier, simpler rule: manifest and ciphertext had to be in an L1 block before the release round, and a miss made the batch invalid, which I would still have had to report.
After the round, the beacon signature is checked against quicknet's fixed public key. The same beacon both decrypts the generator and enters the seed. One value doing two jobs is not two independent draws, and I do not claim otherwise.
b1's seed is a SHA-256 over a domain string, the chain hash, the round in decimal and the beacon randomness, with hex fields lowercased first. The exact sentence is in b1's manifest. v2 batches add a 32-byte secret stored inside the ciphertext, and hash length-prefixed fields: domain, chain hash, round, signature bytes and that secret. The JSON randomness field is not an input; it must still equal the SHA-256 of the signature. I chose the secret. It does not let me list the questions before the beacon exists. A successful tle -d only shows the ciphertext opens under the signature it was sealed to. The BLS check against the fixed public key is a separate step.
There is one specific gap in v1 worth naming. The November capsule cap and b1 share the same plaintext tarball, SHA-256 e054f1ab7824fde33e6ac399252098cf25c29815ff4ffacabbd311da05eac9c2. Once b1 opened, that program was public. Until 2026-11-15 the unknown is the beacon, not the program. v2 still hides its questions, because the secret sits inside the ciphertext.
Four small models, one CPU, three question families
Every family has a program for an oracle, so grading is code and not a judge model. arith_word produces two-to-five-step integer word problems; the oracle is a function of the sampling parameters, and the prompt contains no answer line. code_output produces short Python programs with no imports and no input, run in an interpreter with a step budget; the oracle is their stdout. graph_p
Debugging Missing Results in a Multistage Search Pipeline
A reader searches a library catalog for a book the library definitely owns. The request succeeds, latency looks normal, and the results page is full of plausible alternatives. The expected book is missing.
The ranking model is the obvious suspect. But tweaking scores cannot help if the book never reaches the model. It might be absent from the serving index. Retrieval might cut it off at a candidate limit. A filter might reject it on a technicality. Or the page might lose it during assembly. Each explanation needs different evidence and a different fix.
The argument of this piece: before you tune anything, find the first stage where your candidate stopped progressing. Everything else follows from that.
A good score in a report can be misleading here. A book that would have ranked first still cannot appear if it was never in the ranking input. Counterfactual scores do not describe the actual request.
Walk the pipeline in order
Most search systems pass candidates through the same five stages. A missing result means the candidate left this chain at some point, or never entered it.
- The index snapshot defines what exists and can be served for that request.
- Retrieval pulls a fixed number of candidates.
- Eligibility filters drop items that break rules, such as language or region constraints.
- Ranking scores what survived and sorts it.
- Result assembly dedupes, applies business rules, and cuts the visible page.
Walk these in flow order. Later stages inherit everything earlier stages did wrong. The first link that broke is the one to fix.
Pin down the request first
“Search quality got worse” is too broad to debug. You need one specific request and one specific item: item b04 was missing from request R, which used index snapshot S and configuration C. That gives you something to reproduce.
Preserve the context: normalized query, locale, eligibility rules, experiment assignment, and personalization inputs. A replay against today's index with default settings may describe a different request. Keep sensitive inputs under access control.
Record what happened to each candidate
Request timings tell you where a system spent time, not where the result set changed. For diagnosis, you want each stage's decision on a candidate: kept, dropped, or never seen, plus the reason.
A compact event record works well: request ID, candidate ID, stage, action, and a reason code. Ranking events can add score and position; display events can note items cut by the page limit. Keep shared context such as index, model, and code versions in a request-level record so you do not repeat it per event.
Two cautions. First, a reason code records what the code decided, not that the decision was right. An event saying language mismatch only helps if you check the stored value, the requested value, and the intended comparison rule. Otherwise it just labels a wrong decision.
Second, some candidates have no events at all. If retrieval never emitted the item, there is nothing to record downstream, and the absence of events cannot distinguish an indexing failure from a cutoff or a query mismatch. Keep two extra facts for those cases: does the item exist in the request's snapshot, and where does it sit in the full retrieval ordering? A position beyond the candidate limit explains the silence. In production, use a targeted lookup against the same snapshot or a controlled replay, and write down what the diagnostic actually proved. Say unknown where the evidence runs out.
Three ways a result goes missing
Consider a fictional library catalog where our target book is fourth in retrieval order but would rank first on relevance if it reached the ranker. Three separate faults remove it, each at a different stage.
The first fault is a stale index snapshot: the current catalog has the book, but the snapshot the request served from omits it. A membership check against that snapshot comes back false, stopping the investigation before retrieval or ranking. That establishes absence from that snapshot, nothing more. Ingestion failures, rejected documents, or a request routed to an older generation could each be upstream causes, so you need ingestion and routing evidence to tell them apart. Verify fixes against the snapshot the request actually used.
The second fault is a filter rejecting an eligible item. The book reaches retrieval with stored language en, but a bad configuration requests EN and compares with case-sensitive equality, so the filter event reports a language mismatch. Comparing the stored value against the intended lowercase contract exposes the mistake. The telltale symptom is breadth: this fault rejects every retrieved book, so the displayed set is empty. The fix follows the field's contract. Do not normalize blindly, though; some identifiers are case-sensitive by design, and authorization rules deserve stronger guarantees than a convenient string conversion.
The third fault is retrieval truncating the candidate set. The book is in the snapshot and fourth in retrieval order, but the configuration retrieves only three candidates. The filter never receives it, so there is no filter event at all. Membership lookup, retrieval position, and the configured limit together locate the loss. In production, raising candidate counts adds retrieval, feature-loading, and ranking cost, so measure cost and coverage before making it the general answer.
Compare against a baseline and find the first divergence
When candidate IDs are stable, a baseline run and the changed run are easy to compare. Walk both histories in pipeline order and stop at the first divergence. If the snapshots differ, a later score difference is probably a consequence of changed inputs, not a model problem. If retrieval is identical but filtering differs, compare filter inputs and rules before you retrain anything.
Also mark your evidence complete or truncated. A request that timed out halfway should not look like a complete history.
Keep the evidence affordable
Recording every candidate transition for every request grows with traffic and candidate counts. Sample bounded diagnostics, cap the event budget, and keep retention short. Keep lightweight stage counts everywhere, and collect detailed histories only for selected investigations.
Privacy matters here too. Hashing a user ID does not make a record safe to expose. Queries, item identifiers, feature values, and eligibility decisions can still reveal sensitive information. Treat diagnostic traces like production data.
Before you declare a cause
Run this check on the missing item:
- Did it exist in the serving snapshot?
- Could retrieval have included it?
- Did filters apply the intended rules?
- Did the ranker receive it?
- Did assembly keep it within the visible range?
When one of those lacks evidence, report the gap. The next useful change may be better instrumentation, not a different ranking model.
Most missing-result investigations end where they should have started: the stage that quietly dropped the candidate. Ask where it stopped progressing, collect evidence at that boundary, and the fix usually becomes obvious.
How to predict the behavior of molecules from scant data
Discovering new molecules for specific uses is a major driver of progress in a wide variety of industries, whether it’s pharmaceutical companies looking for new drugs, or electronics or energy companies seeking new materials with particular properties. But it’s also largely a trial-and-error process, because there is not yet any way to perfectly predict how a given chemical compound will behave in terms of the myriad different properties and responses materials can exhibit.
Recent progress has been made on using artificial intelligence and machine learning to supplement or speed up laborious calculations based on physical principles that can at least provide some initial guidance on which compounds might be worth synthesizing and testing. Now, a new method developed at MIT shows that when there are few data on some technologically relevant property, such as ligand affinities for a recently discovered cellular target for a potential drug, this approach can outperform other existing methods for winnowing down the field of possible molecules that might be worth looking at.
The findings were reported in the Sept. 14 issue of the Journal of Chemical Information and Modeling, in a paper by MIT graduate student Akshat Shirish Zalte and recent graduate Jackson Burns PhD ’26, Research Scientist Charlles Abreu, Professor William Green, and three researchers from the chemical company BASF.
An earlier version of the paper has been online since last year, and the open-source model the team developed, called CheMeleon, has already found regular use by several pharmaceutical companies. CheMeleon was built using ChemProp, an open-source machine-learning package also developed and maintained by the Green group at MIT, and anyone can download CheMeleon through ChemProp and fine-tune it for their own purposes.
Earlier this year, there was a contest organized by OpenADMET for trying to predict the properties of a variety of new molecules that had not previously been synthesized, says Green, who is the Hoyt Hottel Professor of Chemical Engineering. “It was a big contest, a lot of people participated,” he says. When the winners were announced, it turned out that nine of the top 20 entries had used CheMeleon in their process. “So then we started getting all kinds of inquiries from the pharma companies about this, but our paper had just been submitted; it wasn’t even peer-reviewed or anything yet.”
While the paper went through that review process, its influence was already spreading. At least one pharma company, Green says, “sent a message to all their people, and said ‘Anytime you’re modeling a property, start with CheMeleon, that’s our new company policy’” when making initial decisions about which molecules to pursue.
The key to CheMeleon was pre-training a machine-learning model with detailed data about a million different molecules, so that it gets to learn correlations between the structure of a given molecule and how it behaves with respect to a catalog of about 1,600 descriptors that have been developed by chemists over decades. CheMeleon can then be fine-tuned to predict well-known properties like solubility and viscosity, to more esoteric properties such as bioactivity or reactivity, with a certain protein or enzyme.
Those million molecules are a minuscule fraction of the innumerable ways that atoms can bond together, but they provide enough examples so that once the AI system has been trained on them, it can work out on its own many underlying patterns and relationships, and then apply those to a new, unknown molecule that’s presented to it.
“Most of today’s deep-learning models require more data than traditional methods,” says Zalte. Some successful models use extensive data from the published literature in chemical journals, he says. “We don’t look at the literature at all. We just calculate a bunch of molecular descriptors like molecular weight or number of oxygens, among others.” Then predicting those descriptors forms the basis for their pre-training task.
CheMeleon is a pre-trained foundation model. Inspired by the well-known foundation models in language such as ChatGPT and Claide, which essentially are developed by feeding them massive amounts of information from the internet, CheMeleon uses molecular descriptors of a million molecules from PubChem, a large, freely available database of chemical information maintained by the U.S. National Institutes of Health.
With classical expert-driven models, on the other hand, specialists in a field manually input detailed knowledge about their subject. In developing these classical models, he says, for example, people know from experiments that a certain property of interest, say solubility, may relate to particular descriptors of the same molecules, “like molecular weight, or the number of oxygens that are present, or how branchy or bulky the molecule is.”
With this team’s approach, they can start with an existing neural network architecture and train it to learn underlying principles. “We’re not training it for a specific property, but as a general model that understands some level of chemistry, so that even if you fine-tune it with just a few data points for the task you care about, you can still get some good performance,” he says. That’s thanks to the fact that the model is “not having to learn everything from scratch.”
To verify its usefulness, “We compared our model not only against other foundation models that are out there, but also with classical models leveraging expert-designed principles,” Zalte says. Comparing its performance across 58 test cases, “we see that our model comes out on top.”
Green adds, “The CheMeleon foundation model drastically reduces the number of molecules that need to be tested experimentally to accurately predict the properties of new molecules. This is a huge advantage, since synthesizing and testing a large number of molecules is slow and expensive."
Besides the MIT members, the team also included Jochen Sieg, Christian Feldmann, and Miriam Mathea, researchers at BASF SE in Germany. The work was supported by the Machine Learning for Pharmaceutical Discovery and Synthesis consortium, along with fellowship support from U.S. Department of Energy and MathWorks.
MacBook Air Drops to Lowest Price in Months With Amazon's $250 Discount
Note: MacRumors is an affiliate partner with some of these vendors. When you click a link and make a purchase, we may receive a small payment, which helps us keep the site running.
Colors on sale include Midnight, Sky Blue, and Starlight, and each has an estimated delivery date around November 7-8 for free options. If you're shopping for accessories to pair with a new MacBook, check out our post on the best early Black Friday accessory discounts, with savings on headphones, chargers, cases, and more.
If you're on the hunt for more discounts, be sure to visit our Apple Deals roundup where we recap the best Apple-related bargains of the past week.
Deals Newsletter
Interested in hearing more about the best deals you can find during the holidays? You can sign up for our Deals Newsletter and we'll keep you updated so you don't miss the biggest deals of the season!
This article, "MacBook Air Drops to Lowest Price in Months With Amazon's $250 Discount" first appeared on MacRumors.com
Discuss this article in our forums
Best Buy's Black Friday Event Begins With Sitewide Savings on Apple, TVs, More
Note: MacRumors is an affiliate partner with Best Buy. When you click a link and make a purchase, we may receive a small payment, which helps us keep the site running.
Best Buy's Black Friday Schedule
Best Buy's early Black Friday sale begins today, and new doorbusters will go online every week in November. On November 19, the retailer's Black Friday sale will officially begin and run through November 28. We've broken down the schedule below:
- November 6: Early Black Friday deals + Doorbusters
- 11/19 through 11/28: Black Friday sale
- 11/29 through 11/30: Cyber Monday sale
- 12/18 through 12/24: Last-Minute Savings Event
Best Buy's Early Black Friday Sale
You'll find plenty of Apple devices on sale during this event, including MacBook Air, Apple Watch Ultra 3, iPhone Duo, and more. Of course, there are plenty of non-Apple products to shop as well, including the best prices of the year on select TVs and gaming laptops.
Some of these deals will require a My Best Buy Plus or Total membership, which begin at $49.99 per year. With My Best Buy Plus you will get free two day shipping, exclusive discounts, and an extended 60-day return window on most products.
Apple
- Apple Watch Ultra 3 - $549.00 ($250 off)
- 13-inch MacBook Air (16GB/1TB) - $1,349.00 ($250 off)
- 15-inch MacBook Air (16GB/1TB) - $1,549.00 ($250 off)
- iPhone Air (256GB Unlocked) - $919.99 ($180 off)
- Apple TV 4K - Double rewards for My Best Buy Plus/Total
- HomeView - Double rewards for My Best Buy Plus/Total
- iPhone Duo - Save up to $1,200 with qualified activation and trade-in
TVs
- 65-inch Insignia LED 4K Fire TV - $299.99 ($150 off)
- 55-inch TCL Mini LED Smart TV - $479.99 ($320 off)
- 48-inch LG OLED 4K Smart TV - $599.99 ($600 off)
- 65-inch Samsung OLED 4K Smart TV - $899.99 ($1,200 off)
- 55-inch Hisense Mini LED Smart TV - $899.99 ($600 off)
- 55-inch LG evo AI 4K Smart TV - $999.99 ($1,000 off)
- 50-inch Sony BRAVIA 7 II 4K Google TV - $1,299.99 ($300 off)
- 65-inch Samsung OLED 4K Glare-Free TV - $1,399.99 ($1,300 off)
- 75-inch Samsung 4K Smart TV - $1,699.99 ($1,100 off)
- 75-inch Samsung The Frame Pro 4K TV - $1,999.99 ($800 off)
Appliances
- GE High-Efficiency Top Load Washer - $579.99 ($185 off)
- Samsung High-Efficiency Smart Top Load Washer - $849.99 ($140 off)
- KitchenAid Dishwasher with ProDry System - $899.99 ($320 off)
- LG High-Efficiency Stackable Smart Front Load Washer - $929.99 ($370 off)
- GE Smart Top Load Washer and Smart Electric Dryer Bundle - $1,099.98 ($790 off)
- Frigidaire Counter-Depth French Door Refrigerator - $1,399.99 ($400 off)
- Samsung 4-Door French Door Smart Refrigerator - $2,199.99 ($860 off)
- GE 4-Door French Door Smart Refrigerator - $3,199.99 ($760 off)
- Bosch French Door Counter-Depth Smart Refrigerator - $3,599.99 ($400 off)
We're keeping track of all of the season's best Apple-related deals in our Black Friday roundup, so be sure to check back throughout the month for an updated list of all the most notable discounts you'll find for Black Friday 2026.
Deals Newsletter
Interested in hearing more about the best deals you can find during the holidays? Sign up for our Deals Newsletter and we'll keep you updated so you don't miss the biggest deals of the season!
This article, "Best Buy's Black Friday Event Begins With Sitewide Savings on Apple, TVs, More" first appeared on
AI agents may run your household. What could go wrong?
Erica Layer, a mom of a 2- and 6-year-old, has an enviable to-do list for her AI agent.
The busy executive relies on an Instinct agent for low-stakes but time-intensive household tasks like meal planning, calendaring, and birthday reminders.
"I do get a huge amount of time back," Layer says of delegating to an AI agent. "But also I'm doing the things that I just was dropping completely before."
Still, Layer is conflicted about her agent's persistence. The AI has suggested completing tasks on her behalf without explaining what happens to the data it accesses. Recently, her Instinct agent researched a family trip in Portugal, where she lives, and offered to book train tickets.
The catch? It wanted her kids' passports to make the purchase. Layer runs a fractional AI company, operates her own team of agents professionally, and has taught nearly 100 people to build agentic operating systems. She consulted Instinct's data privacy terms, felt they lacked transparency, and worried about how her data would be used. Layer, who wrote about her experience, made the reservation herself instead.
Mashable attempted to contact Instinct's founder for comment but did not receive a reply as of publication.
Like many parents — particularly moms — Layer is eager for an agent to handle the exhausting aspects of running a household. At the same time, she's unwilling to connect her personal data to a platform without clarity about its policies.
Parents are poised to be among the earliest adopters of AI agents for their families, yet unclear risks may compromise their personal and sensitive data. Experts say the excitement over agentic products for families is warranted, but that parents should first grasp how to best protect their data.
"I would love to have this mental load out of my head"
In a few short months, overwhelmed parents in the U.S. suddenly have their pick of agentic products. The September launch of Meta's Muse, reportedly in response to Instinct's early success, sparked instant competition. OpenAI quickly followed with its AI agent Dots, and Anthropic opened a waitlist for its "proactive" agent Claude Duet.
These products have overshadowed startup offerings like Fambot and Fo, both created by working parents and tech executives turned entrepreneurs. Fambot bills itself as a parent's "AI chief of staff" and Fo insists it'll "get sh*t done."
Meanwhile, Marissa Mayer, formerly the CEO of Yahoo, debuted her AI agent Dazzle to viral controversy after sharing with the New York Times that she asked her AI agent to choose three of her twin daughters' standout qualities for a school birthday slide. Mayer said on X the anecdote lacked important context about trying to challenge Dazzle with the prompt.
Either way, Layer wrote on Substack that she didn't appreciate how the response to Dazzle minimized the value of AI tools for households, particularly for working moms.
S. Shyam Sundar, director of the Penn State Center for Socially Responsible Artificial Intelligence, says parents who turn to AI to save time on tedious tasks aren't being selfish.
"I think it's looking out for more the psychological welfare of the household and the relationships within that household," he said.
Amy Wu Martin, a new mom and partner at the early-stage investment firm Menlo Ventures, says she's saved a lot of time letting Muse and Claude research whether restaurants and hotels are kid-friendly.
"I would love to have this mental load out of my head," she says of mundane parenting tasks.
Parents as early AI adopters
Menlo Ventures' survey research suggests parents are indeed AI power users. They are nearly twice as likely to use AI daily as non-parents. Among parents polled by the firm, 40 percent use AI daily for tasks like meal planning, shopping, and logistics. She envisions a future in which AI agents can handle purchases for parents, like ordering diapers.
Personally, Wu Martin has stopped short of connecting her inbox to an agent because of data security concerns. She's open, however, to letting an AI agent coordinate calendars with her husband.
Fambot, co-founded by dad of three and former Uber executive David Reich, turns school emails, sports schedules, and parent chats into a clear daily plan.
The agent gets read-only access to a parent's inbox, calendars, and WhatsApp groups and proceeds to manage every task it perceives relevant. It parses the school newsletters, sports schedules, and parent chats, then generates specific action items, calendar events, and a text summary each evening of what the parent needs to know.
Shivani Poddar, who previously worked as a senior engineering lead at Google DeepMind, recently launched the AI agent Fo through her startup Wajo AI. While it's not designed specifically for parents, Poddar says she relies on it for tasks like reminding her to buy a Halloween costume well in advance and finding a Mandarin class in San Francisco for her toddler. Fo can also bring a human customer service agent into its loop if necessary.
Really, Poddar says, she's looking to gain time back to spend with her child, and she knows other parents want that, too.
AI agent privacy and safety red flags
Kayne McGladrey, a virtual chief information security officer, says parents who want to use an AI agent can take reasonable privacy precautions.
Yet he understands that many consumers have developed "privacy nihilism." They feel like their digital lives will be compromised at any moment regardless of their choices. That can make vigilance feel like a losing battle, especially when privacy and security policies are dense and packed with jargon.
Privacy phrases to watch out for
He recommends evaluating an agentic product's marketing claims, especially those related to privacy and security. Consumers should look for phrases like "zero retention," "zero training," "no storage on the provider's server," and "zero-knowledge encryption."
Such phrases indicate the company's data practices prioritize consumer privacy and security by storing information carefully and limiting whether it's used to train AI models.
McGladrey, a senior member of the Insti
