Tag: Open Source

Reading List – 2026-10-26

Allen Hutchison1 Comment

Across the agent pieces, autonomy keeps landing on familiar engineering boundaries: who can write, what a worktree isolates, and what context survives a reset. The sources describe controls, not proof that they hold under every failure mode. I find that distinction worth keeping in view: delegation can reduce hands-on work, but it still leaves teams owning authorization, coordination, and review.

Partyline: A group voice application for Reticulum, built on LXST

Partyline's slow-link rooms trade latency for fewer, fuller packets: they pack audio to fill the link's MTU and give listeners larger jitter buffers to smooth bursty arrivals. The project recommends these push-to-talk rooms with Codec2 and says they can coexist with regular rooms, so the server can serve links with different capacities. I like that the constraint is explicit; operators still need to choose a buffer depth their conversations can tolerate.

Sebastian Raschka's from-scratch video course on building reasoning models

The same math verifier serves as both the MATH-500 grader and the reward signal for reinforcement learning with verifiable rewards. It extracts answers, normalizes them, then checks mathematical equivalence, so one set of rules shapes both evaluation and training. I’d pay attention to those rules’ edge cases: a verifier’s blind spots can affect what the model learns and how much we trust its reported scores.

Where Tailscale VPN ends and Tailscale PAM begins

VPN connects devices; PAM instead places a connector on each target network to mediate access to specific services. That adds a hub-and-spoke dependency, though the article says multiple connectors can provide redundancy; connectors also enable per-service permissions, credential injection, and session records. What catches my attention is the operational bargain: fewer clients and shared passwords to manage, but connector coverage and failure planning become part of access design.

Tokens Over Hires

Tokens aren't the bottleneck once agents are cheap; human attention is, especially for approving plans, reading pull requests, and handling escalations. The described pipeline keeps agents from merging and handles triage, planning, and first-round review, so each change reaches a person when it merits careful attention. I find the hiring implication more interesting: another coder can add review work, while someone who owns a bounded service brings their own supervision. That boundary matters more than raw agent count.

GitHub – ParadevAI/Paradev: Superset is an agentic IDE to orchestrate 100+ coding agents in parallel. Run any agent with your own subscription. · GitHub

Superset gives each parallel task its own Git worktree, but the project notes that worktrees don't sandbox processes or prevent merge conflicts. That separates working files without isolating everything, so teams still need to account for process interactions and reconcile competing changes. I appreciate that the boundary is explicit: I’d treat worktrees as coordination, not containment.

IBM CEO says open weight models are now irresistibly good and cheap on-prem

Krishna’s case for open-weight models rests on a cost gap: he says they’re about 90 percent as effective as frontier models for 10 to 25 percent of the token cost. But running them on-prem still requires kernel and network expertise, GPU placement, and careful caching; he says many enterprises will struggle to assemble that capability. What catches my attention is that the savings depend on operational work the cheaper model doesn’t remove. The real comparison includes the cost of building and maintaining that stack.

I love to put things in boxes!

Boxi’s tiny corner pieces connect boxes in thousands of sizes for different drawers, while the shelf system uses flush connectors for tool-free expansion. The design bet is that a small, repeatable connection makes customization and later growth possible without fixing each piece in one arrangement. I’m curious where that flexibility starts to add more parts than a household can usefully manage.

Kimi K3.1 Pro release, benchmarks and cyber safeguards

Kimi K3.1 Pro’s cyber controls remove cyber-related data from mid-training and filter cyber tasks from reinforcement learning, while keeping general coding tasks. The company reports 81.0% pass@3 on its exploit benchmark, versus 90.5% for a checkpoint without those controls. What catches my attention is the stated residual risk: stronger general coding still transfers to vulnerability work, so data filtering reduces capability rather than drawing a firm boundary. For open-weight releases, that makes ongoing evaluation part of the safety mechanism.

Kimi K3.1 Pro scores 55 on Artificial Analysis, well above the comparable-model median of 27, at median input and output prices. The tradeoff is that it generated 150 million tokens on the index, versus a median of 87 million, and ran at 73 tokens per second, below the 81-token average. For software that pays per output token, verbosity can matter even when benchmark task cost averages $2.11. I’d want to know whether those extra tokens help on the workloads we actually run.

The Highspeed tier makes latency a workload-pricing decision: Moonshot says it runs 2–3× faster for twice the price, while cached input tokens stay at the same price. The premium therefore isn’t uniform across a request; its cost depends partly on how much input is reused, while output pricing doubles. I’d compare the tier against actual cache-hit and output-token patterns before treating the speedup as a general throughput win.

Kimi K3.1 Pro is counted as open before its weights are available: until 4 November, it runs only through Kimi’s API. That makes the reported 31-day gap a measure of announced openness as well as model capability. I’d separate benchmark quality from operational control when assessing it; the latter still depends on whether the promised weights arrive and can be run where they’re needed.

Moonshot says it removed cyber-related material from both training data and reinforcement-learning environments to reduce offensive capability while keeping general coding intact. Its internal vulnerability-finding benchmark fell from 90.5% for an unmitigated version to 81%, though those results haven’t been independently verified. What catches my attention is that the safeguard acts before release, while open weights limit control afterward. Teams should test the reported tradeoff against their own security tasks rather than treat it as a durable boundary.

Kimi K3.1 Pro · Kimi K3.1 scores 55 on Artificial Analysis, placed on the Pareto line · Introducing Kimi K3.1 Pro · Kimi K3.1 Pro puts open-source AI a month behind the best · Moonshot tells Kimi AI to code away, but leave the hacking alone

OpenAI and Anthropic cut their LLM prices by up to 80% within a few months. Why?

For coding agents, cache-read pricing can outweigh headline token rates: the article says cached reads account for 96–99% of token expenditure, with cache hits around 90–100%. It reports that Fable 5.1’s 75% cache-read cut corresponds to a 70–75% lower total cost. That makes price comparisons incomplete unless they reflect a workload’s cache behavior. What catches my attention is how much the economics depend on the serving path; teams should measure effective cost on their own agent traffic before switching.

The State of Context Engineering

The useful boundary in context engineering is deciding what the harness should enforce deterministically and what the model should decide probabilistically. The talk describes filtering tools, pruning history, and handing subtasks to agents with fresh contexts; for long-running work, some approaches clear the conversation while preserving artifacts. What catches my attention is that forgetting becomes an explicit control mechanism, not just a response to a bloated prompt. For software teams, the hard part is choosing what state survives a reset without discarding useful work.

AI use leads UC Berkeley math professor to see 'no point' in grading homework

Borcherds stopped grading homework for correctness after students used AI to receive consistently high scores; now he grades completion and calls it a poor system. A completion grade records submission, but doesn't establish what students can do themselves. I’m struck by how little room there is for a reliable substitute: Berkeley found its detection tools inadequate to standardize. For assessment designers, completion is a fallback, not evidence of mastery, and the replacement remains open.

Resend Inboxes Announcement

Email's thread model can be surprisingly loose: Resend says conversations often depend on headers and subject/sender matching. Inboxes make threads, labels, drafts, and assignment explicit, while an incoming message can trigger an agent to label it and draft a reply. I like that the agent can prepare a response without taking sending away from a person. For teams building agent-backed communication, the open question is whether this structure keeps context and ownership clear as conversations move between agents and people.

Apple Doesn't Make This Useful Desktop Touch ID? Wireless Mac Fingerprint Unlock | IMMUROK Review

Recognizing the reader as a PIV smart card, rather than a fingerprint peripheral, is what lets it work around macOS's limits on third-party scanners. Device-generated keys and cryptographic challenges support authentication, while the review says fingerprint data stays on the unit. I find the physical-device boundary more interesting: Bluetooth pairing checks and tamper response are described, but a stolen, unopened reader gets only a keep-it-safe recommendation. That makes custody part of the trust model, alongside local biometric storage.

Five Qwen3.8-27B models match Fable 5 Using GVS5H Harness

The interesting move is giving fresh instances of one model a shared filesystem for the plan, notes, and current solution. The paper reports that this ledger-based orchestration lifts Qwen3.8-27B from 69.2% to 92.4% on 100 hard LiveCodeBench problems, slightly above Fable 5’s 90.4%. I find persistent context more interesting than the headline score: it makes coordination part of inference without training. That makes orchestration worth benchmarking separately from model choice, though the gains aren’t universal or established beyond this coding benchmark.

Argus open-source security operations platform

Argus says its AI agents are read-only: they investigate and propose, while every change passes through one broker. Autonomous response starts off, and playbooks begin in shadow mode; reversible actions roll back unless someone keeps them. I find that boundary more interesting than the promise of machine-speed response, because authorization and reversal are built into the execution path. Teams still need to tune rules and monitor before enabling actions, so the operational work shifts rather than disappears.

Argus keeps agents read-only: their sole write-capable tool creates a pending ActionRequest, while a separate broker handles policy, approvals, dry runs, execution, and rollback. It gives permissions and failure controls a distinct enforcement point, rather than trusting a prompt. What catches my attention is the validation gap: cloud and identity collectors are fixture-tested, not against live accounts, and the 12 detection rules are untuned. Argus recommends a monitoring-only rollout before enabling actions, a sensible boundary for an early foundation.

Argus – a free, open-source agentic security operations platform – MIT · Show HN: Argus- open source security platform to protect against agentic attacks

No Signs of AI Payoff Outside the Tech Sector

AI's payoff remains concentrated in the Mag 7, the article reports: revenue per worker and margins rise there, while the S&P 493 stays flat. It argues that business value also depends on judgment shaped by context, accountability, trust, and unwritten rules. That fits my view of AI as akin to the PC: workforce training takes years, so early gains in specific companies shouldn't be mistaken for broad productivity growth. For software leaders, that argues for measuring workflow-level results before projecting wider returns.

Moom · Many Tricks

Moom can restore saved window layouts from a hot key or menu, and trigger them when a display is added or removed. That makes display changes a useful boundary for switching arrangements, rather than requiring a manual reset each time. I’d want to know how it handles windows that don’t match the saved layout; the description covers positioning, but not conflict behavior.

Reading List – 2026-10-21

Allen HutchisonLeave a comment

The agent workflows here depend on written constraints and design docs staying coherent as code changes. That shifts maintenance work from prompt setup to keeping those inputs and checks current. Separately, rising inference prices make token-heavy features an operating commitment. I’d treat caching and workload-specific cost checks as design concerns, not cleanup for later.

New prize launches for books co-written with AI

The Prix Pascal makes AI co-writing explicit: entrants submit unpublished French fiction, 10,000–50,000 words, and identify the model and prompt. I like the sound of it; it even has me considering whether to dust off my half-finished manuscript, though entering remains a maybe. The harder constraint is that fiction must also help solve an ethical, social, or ecological problem, so a submission has to satisfy two ambitions at once.

The Success Trap

The career risk here isn’t only that a skill expires; a reputation can harden around the old way of working, even while those skills remain useful. The article makes that tension concrete: one employee keeps today’s organization running, while another builds experience with emerging technology, and the first may lose out after the transition. What catches my attention is how hard it is to protect time for that second track without neglecting the systems and teams that still depend on the first.

Rust off Rails: The opinionated web stack for the AI era

Rust off Rails puts its conventions, recipes, and stack choices in 60 Markdown files; an agent generates app code and tests it on SQLite and Postgres. The framework is the written constraint set, not a shipped library, while the generated code stays in the app. My maintainerd plugin has the same shape: Markdown skills and an agent loop run my software factory. The approach depends on keeping those written decisions coherent as the conventions evolve.

Design Docs, Nightly Audits, and Vycari’s Agent Development Loop

What stands out is that Vycari treats design docs as maintained inputs to agent work, not artifacts that go stale after planning. A nightly process compares them with code changes and proposes updates; PR follow-ups become issues with enough design detail for the implementation pipeline. That makes documentation quality and issue detail part of the system’s operating surface, not just project hygiene. I had fun recoding this conversation with Dan, and hope other people find the workflow useful.

Speeding up code review with `small-change` | Irrational Exuberance

Proposal for Allen to review: Imprint’s small-change gate uses concrete proxies—under 1,000 lines, an experienced author, limited service impact, and no high-severity AI-review findings—to make some PRs eligible for fast approval. I like the direction, but “small” seems less useful than low risk: a risk estimate from low to high could set the amount of review each change gets. Only about 10% qualify so far, so expanding coverage still depends on stronger verification.

DeepSeek Dials Up the Pressure on OpenAI and Anthropic With Open-Source Inference Tool

Inference cost is becoming a product constraint, not just a serving-team metric. DeepSeek has made its production inference stack, DeepInfer, available on GitHub, though it currently supports only V4-1 Flash. The article says techniques such as speculative decoding could lower costs further; what catches my attention is how tightly those gains may depend on the model. For teams weighing a switch, the unresolved question is whether the savings hold for their workloads and deployment constraints.

Alibaba hikes DeepSeek V4 Flash 0731 output prices by 230%

Proposal: Alibaba raised DeepSeek V4 Flash 0731 output pricing from $0.40 to $1.32 per million tokens, a 230% increase. I read that as a sign that subsidized inference will become more expensive and less generous, especially for frontier and coding models. For teams building token-heavy features, this makes cost controls like caching and tighter prompts part of the product’s operating assumptions, not just later optimization.

LayerFS: The filesystem for AI coding agents

Each agent gets a writable workspace over shared committed history and commits its own changes, a useful shape for parallel work. I lose time getting agents’ dependencies set up, so a shared dependency layer would catch my attention, though this description doesn’t say LayerFS provides one. If it does, the question is how that shared setup stays reliable while agents work independently.

Reading List – 2026-10-12

Allen HutchisonLeave a comment

Across these pieces, capability keeps running into the conditions around it: review capacity for generated code, a harness that shapes an agent’s results, and clear boundaries for connected tools. I’m struck by how often the hard part shifts from getting a model to act to making its behavior inspectable and dependable in the workflow. That’s where deployment judgment still matters.

AI Is a Tool. Using It Well Takes Skill.

An LLM can be a tool even when it automates work: a programmer can ask it to explain unfamiliar code, check the answer against the source, test a suggested change, then refine or reject it. The article argues that this feedback loop still depends on human direction and judgment. What catches my attention is the skill it requires: the operator needs enough context to spot a bad answer, so review capacity remains part of the engineering cost.

GLM-Legal: Advancing Agentic Legal Intelligence

The engineering choice worth noticing is co-training the model and its harness: context staging, tool routing, and runtime feedback are treated as part of task performance, not plumbing. The authors report a 19.2% all-pass rate on Harvey LAB, up 12.5 points from the base model. I find that end-to-end framing more informative than a reasoning score alone, though the result also shows how demanding strict task completion remains. For agent builders, harness behavior belongs in both training and evaluation.

2027 Rivian R2 review: The Goldilocks electric SUV

The R2’s hands-free system is much more dependable on highways than on surface streets: it can disengage within seconds when lane markings aren’t distinct enough. It handled highway curves and lane changes well, but local-road performance depended on the specific road and nearby lines. What catches my attention is how much the feature’s usefulness depends on its operating conditions; the driver still needs to supervise, especially off the highway.

Muse

Meta is making active memory a differentiator for Muse Wonder. Its evidence includes MemoryBench, which tests continual learning and memory construction; Meta says Wonder scored higher than Fable, Opus, and Astra. For teams building long-running assistants, that makes memory quality worth evaluating separately from coding or general benchmark scores. I’m curious how well MemoryBench predicts useful recall across real user histories, since the source doesn’t report deployment results.

Muse reportedly gets hourly instructions to maintain a page for every person in a user’s life, including relationship history, closeness, and recurring topics. That makes context collection extend to people who may never use the agent. Meta says each user’s data stays in a dedicated secure virtual machine, but that doesn’t answer how nonusers’ information is represented or controlled. I’d treat that third-party context and its lifecycle as a product boundary, not merely a memory feature.

Muse’s new connectors reach tools such as GitHub, Dropbox, Figma, and QuickBooks, while a business goal can prompt it to autonomously plan marketing, client pitches, and product pages. That shifts the agent from chat toward work that spans connected systems, though the article doesn’t explain what approval or guardrails apply. I’d want to understand how users review a plan before it can affect those tools.

Keeping inference on users’ Macs or PCs makes the privacy boundary concrete, but Underdog currently relies on a 27-billion-parameter model fine-tuned from Qwen3.8 27B. Wen says it compares favorably with Claude Opus 4.6 on some benchmarks; that’s not evidence of parity across all the sensitive, open-ended tasks an assistant might handle. I’m interested in whether the local model is useful enough to justify keeping data on-device, especially since the article doesn’t establish how it performs in everyday use.

Meta releases its first frontier model, Muse Wonder · Muse launches on the iPad · Meta’s Muse Is Collecting Information on Everyone in Your Life · Silicon Valley’s AI wunderkind launches Underdog, the most private Instinct/Muse competitor yet

Cal AI’s 19-year-old founder just raised $10M for his new AI startup

Persona’s privacy boundary is deliberate activation, not local computation: the band uses a button or wrist flick, while the AI model and user data live in the cloud. The company says data is encrypted in transit and at rest and users can delete it. What catches my attention is the remaining trust burden: activation limits collection, but the article doesn’t explain what data the service retains or who can access it.

Foresight Offline Meeting Assistant

Foresight’s notable choice is keeping transcription and meeting Q&A on the Mac; Google says audio, notes, and connected files never leave the computer. That creates a clear boundary for meeting data without requiring a cloud connection, though the source doesn’t describe model quality or device-level access controls. What catches my attention is the deployment constraint: the experimental app is currently optimized only for Apple Silicon Macs, limiting where that offline approach can be used.

The interesting constraint here is that meeting notes, transcription, and document-based questions can all run offline on Apple Silicon, using a 740-million-parameter embedding model. That keeps the knowledge base available while traveling, but the source doesn’t say how well the local assistant handles larger collections or nuanced questions. I’d want to understand where its answer quality starts to give way, since that boundary determines whether offline use is a dependable workflow or a fallback.

Google’s AI note-taking app transcribes your meetings completely offline · Google releases a new local-first Granola competitor

Whistle: Speech to Text in 16.9 MB

Whistle’s notable engineering choice is a single engine path from speech to tool calls: one C++ binary loads both models, transcribes a clip, and returns tool calls and speech fields in one JSON object. At 16.9 MB, with CPU execution and no dependencies, that could simplify deployment where a separate transcription service is awkward. I’d want to understand how recognition failures are handled before a tool call runs; the article shows a confidence field but doesn’t describe the policy around it.

Amazon builds 1,000th satellite, will launch space internet service by end of year

Starlink about to get some real competition but Amazon is starting from behind with years of catch up launches to match space x coverage.

Apple Announces Next ‘Welcome Home’ Special Event on Oct. 13

I’m looking forward to this one. I’d like to see Apple release a gadget like the Google Pixel Tablet that would connect an iPad like device to a charging base. This is t what the rumors say we are getting but it does t hurt to wish.

Python 3.15.0

The headline JIT gains come with important qualifiers: Python 3.15 reports 7–8% on x86-64 Linux against the standard interpreter, and 11–12% on AArch64 macOS against the tail-calling interpreter. I’d keep those baselines in view before treating the numbers as a reason to change deployment plans. For teams evaluating the release, the useful next step is benchmarking their own workloads and platforms; these figures don’t establish a general speedup.

50MB operating system can resurrect your old PC

What a cool project. I love the idea of making old hardware useful again.

Google’s New Playground Aims to Make It Easy to Vibe Code a Game Right in Your Browser

Playground’s interesting engineering bet is the tight loop: prompt a game, test it immediately, then ask for changes to physics, rules, characters, or environment. Google says a custom harness, refined with internally built games and evaluations, powers that loop alongside its foundation models. The current gallery is mostly simple mini-games, so I’d read this as evidence for quick playable prototypes, not yet for maintaining deeper game systems. The open question is how reliably edits preserve behavior as rules accumulate.

EmDash uses Clef to moderate the plugin registry

EmDash keeps plugin publishing open while making catalog visibility a separate decision: authors retain signed AT Protocol records, and the registry controls what it lists. Clef scores text, links, icons, and screenshots; any category at 0.45 or above sends a listing to an operator rather than blocking it automatically. I like that the model’s uncertainty routes to review, though that puts the practical burden on review capacity. For a registry, the moderation path depends on the team’s ability to handle that queue.

Generated Interfaces for ChatGPT

The interesting engineering choice is to constrain generated interfaces with a library of native, streamable components, then compile them as the model produces them. That lets the UI arrive progressively rather than waiting for a complete response, while the model still chooses layout and interaction. I’m curious how that boundary holds up when a request needs an interaction the library doesn’t cover. For teams building similar systems, the tradeoff is flexible composition versus predictable behavior.

The notable shift is that ChatGPT may choose to return a working interface, not just formatted text: OpenAI says it can draw from a trained library of components. Its roast-planning example includes a control for changing guest count and scaling ingredients. I’m curious how reliably those generated controls preserve the answer’s meaning; as the article notes, visual elements add another place for hallucinations, while richer responses may also use more tokens.

GPT‑6 and Intelligent UI for everyone · OpenAI Wants ChatGPT to Stop Looking Like a Chatbot

Grok Bot Is Now a Model Router as SpaceX Continues to Pivot Further Toward AI Infrastructure

Grok Bot’s model router makes backend selection part of the service. Musk says simple questions go to small, fast models, while complex ones go to larger models. The article reads this as a possible move toward renting AI infrastructure rather than depending on Grok alone. I’d want to know what signal decides the route: quality, latency, and cost can favor different models, and the article doesn’t say how that tradeoff is handled.

Claude Haiku 5.5

Haiku 5.5’s adjustable effort setting makes cost versus intelligence a choice within the model, rather than only a reason to switch models. The announcement says it can pair with Sonnet or Opus as a coding subagent and positions Haiku for narrower tasks like compaction and classification. I’d want to know how effort settings change latency and quality on a real task mix; teams still need to measure that tradeoff before routing work.

Haiku 5.5 matches Luna’s listed price only up to 100,000 tokens; above that, its rates rise fivefold, and the post reports its tokenizer uses about 25% more tokens on the same long prompt than Haiku 4.5. What catches my attention is how easily the per-token price can obscure workload cost. When comparing models, I’d include tokenization and prompt length, not just headline rates.

Claude Haiku 5.5 · Introducing Claude Haiku 5.5

AI Model Groupthink

The panel both supplies the answers and defines the consensus: each model is scored against the other eleven, and five of twelve are Chinese. The article reports higher average agreement among those models, while noting that shared training or style could let a bloc reinforce its own score. I’d treat this less as a model-quality leaderboard than a property of this particular panel; changing its membership could change who looks conformist.

People Holding Up the Internet

Counting changes makes maintenance visible, but it isn’t a maintainer census: the authors count people with ten or more changes and note that authorship doesn’t always mean maintainership. Even with that limit, the concentration stands out: seven of 14 listed Linux packages are mostly written by one person, and bash shows Chet Ramey at 100% of the year’s work. I’d treat this as a reason to inspect ownership and succession, not as a standalone measure of project health.

How Massive Is Elon Musk’s Trillion-Dollar Fortune? Spend It Yourself

The visualization’s 3D effect didn’t require a million 3D models: Agarwal says that many monster trucks would freeze a laptop, so he used other tricks to avoid rendering them as models. I like the constraint-driven choice, though the interview doesn’t say what those tricks were. For interactive graphics, the useful question is where a convincing representation can replace per-object rendering without obscuring what the display means.

I gave Opus 5.5 one prompt and six hours to visualize Invisible Cities

Opus 5.5’s striking result came at a real cost: the Invisible Cities visualization took 1 hour 25 minutes, used six parallel subagents, and ran about $74 in API tokens. The author found it mesmerizing, but this is one one-shot build, not evidence of repeatable design quality; GPT-6 Astra took 53 minutes and about $10, with more visual noise. What catches my attention is the shift from implementation effort to judging whether generated design choices earn their place. For interactive software, I’d treat design review and token budget as part of the build, not assume the prompt eliminates either.

We want you to build the next Git platform on Cloudflare

Cloudflare is drawing a clear boundary: Artifacts provides versioned repositories, programmatic forks, and Git operations, while builders design how agents coordinate, review, and merge work. Push events can trigger a Worker-based review workflow, but the policy for resolving competing changes still belongs to the platform you build. What catches my attention is that this makes agent isolation easy to prototype without making safe integration automatic. Teams still have to define what counts as a reviewable, mergeable result.

Software Engineering Is Dead. Long Live Product Engineering

Agents can write code, but a bakery owner still needs someone to identify which order-tracking tool fits. That distinction matters because a fluent request can hide the product decision, and the article says agents still struggle to draw out requirements. What catches my attention is the maintenance caveat: personal software may still require context engineering, so easier creation doesn’t settle who keeps it useful.

The End of TCP for AI Clusters — John Ousterhout, Stanford

Homa puts congestion control at the receiver: the first packet reveals a message’s length, and receiver-issued grants pace the rest. That lets it favor short messages in switch priority queues, so coordination traffic can bypass large transfers during incast. The talk reports about 13× lower P99 latency for short messages in one benchmark, not across all workloads. I find the receiver’s visibility compelling, but its value depends on the workload being latency-bound and the network supporting those queues.

OpenAI and Anthropic Have a New Threat to Worry About—and It Isn’t China

The interesting bet is that enterprises will trade dependence on closed-model APIs for the ability to build custom models from open weights. Reflection describes software for that job and is reportedly preparing its own open-weight model, but the article gives no technical detail on what building or operating one requires. I’d treat the cost and control case as unproven until those mechanics are clear; teams still need to know who carries the compute and maintenance burden.

Qwen3.8 27B addition in words

Format compliance and arithmetic competence diverged sharply: reasoning-disabled Qwen3.8-27B followed the English-words format in 96.17% of cases, but got 23.57% of sums right. Accuracy fell from 97.04% on one- to three-digit operands to 6.44% on ten- to thirteen-digit ones. Reasoning enabled got 167 of 169 in a paired test, but it was one-shot; I’d treat that as a promising contrast, not a stable estimate. Exact-output workflows still need independent checks, even when the answer looks correctly formatted.

Vinod Khosla believes ex-Deepmind engineer’s Wajo will win agent market on trust

For an agent that can call people and pay on a user’s behalf, trust has to show up in controls: Wajo says users can name trusted contacts and recipients can tell the agent not to call again. Poddar argues agents may not be able to unlearn access to personal data, so trust needs to shape architecture from day one. I find those controls more concrete than a general safety promise, though the article notes one test call had unclear disclosures.

Scrimshaw Jukebox

The interesting test wasn’t just asking a model for music: it had to design a text format and build a playable artifact with example tracks. The reported result was surprisingly good, though it leaned too heavily on Monkey Island. I’d compare recent and older models before calling this a newly emerged capability; the piece leaves open whether earlier models could do it too.

AI is now capable of developing its own inference hardware

Making every data movement an instruction gives openTPU a useful property: there’s no cache or hidden scheduling obscuring where cycles go. Its Lens profiler can trace runs from RTL, simulator, or card, down to per-instruction activity. I like that this makes performance questions inspectable, not just benchmarkable; it also puts the burden on whoever writes kernels to reason explicitly about moving data. That tradeoff matters when maintaining a compiler or optimizing a memory-bound workload.

AI Is Entering Its ‘Slurp Juice’ Era

The risk in AI’s expanding product menus isn’t just confusing names; it’s that usage limits and prices can shift, leaving customers unsure what their subscription actually buys. The article argues that this confusion is becoming a business liability. I find the moving terms more consequential than the product names: teams can’t plan reliably around a service if its allowance keeps changing, so clear pricing and change notices matter as much as new capabilities.

Mistral Large 4 (Le Chonk)

Open weights matter here less as a price point than as control over a dependency: Mistral says businesses can customize Le Chonk and pay only for compute, while a closed provider could withdraw access. That could matter for coding or cyberdefense systems where losing a model disrupts an operational capability. I’d keep that availability case separate from the performance claim: Le Chonk is still in preview, and the article offers no workload-level comparison.

Mistral Large 4 is described as a one-trillion-parameter multimodal model with 49 billion active parameters, but the source gives no deployment or serving details. That gap matters: active parameter count alone doesn’t tell an engineering team what latency, memory, or operating cost to expect. I’d treat the benchmark claims as a reason to test it, not a basis for choosing it, until those constraints are clearer.

Mistral Says Its New AI Model ‘Le Chonk’ Is the Best Open-Weight Offering Outside of China · Meet Mistral Large 4, aka Le Chonk

Reading List – 2026-10-10

Allen HutchisonLeave a comment

Today’s reading connects the tools around AI-assisted development with the judgment behind using them: security review, documentation, token costs, and programming as expression.

Anthropic launches free AI security scans for open-source projects

OSS Scanner trades human triage for faster, more frequent scans: its vulnerability reports are fully model-generated, and Anthropic warns they may be incorrect or invalid. That speed matters only if project maintainers can sort useful findings from noise; the article notes that some projects already struggle with AI-generated bug reports. What catches my attention is whether scan frequency can help without adding more triage work to already-stretched maintainers.

Supercharge your development with the Google Developer Knowledge API ecosystem

The agent skill searches document chunks first, then fetches full Markdown pages or returns a grounded answer. That makes context use a deliberate retrieval choice rather than loading whole documents by default. For a coding agent, I’d treat that sequence as part of the system’s behavior, not just plumbing. I’d want to test whether chunk-first retrieval keeps enough surrounding context when an answer depends on caveats elsewhere in the page.

Five keys to controlling AI token costs

Reranking puts a cheap relevance check between broad vector retrieval and the expensive model: fetch 50 candidates, then send only three or four chunks onward. The article says this can add about 100 milliseconds while cutting prompt tokens by 80% or more and improving accuracy. I like that the tradeoff is explicit: another pipeline step buys a smaller, better-targeted context. For RAG systems, the engineering test is whether those savings and relevance gains hold across your own queries.

Programming Isn't Special

Just like painting can be functional when you are changing the color on the shed in the back yard, programming can be art. It’s not the medium that is important, it’s the expression.

A desktop 3D printer printing a small mechanical part in a home workshop, with filament spools blurred in the background.

The Bill That Wants My 3D Printer to Police Itself

Allen HutchisonLeave a comment

There is a printer humming in my workshop right now, laying down a part one 0.2mm layer at a time. It is a slow, almost meditative machine. It does not know what it is making. It does not know if the object taking shape on the bed is a bracket for my garage shelving, a fidget toy for my son, a one-off template, a jig for my guitar building, or something I should not be making at all. It knows one thing: move the nozzle here, push out this much plastic, repeat a few hundred thousand times. That is the entire worldview of a 3D printer.

I bring this up because the California legislature has decided my printer should know more than that. Assembly Bill 2047 would require every 3D printer sold in the state to run a state-certified “detection algorithm” designed to recognize and refuse to print firearm components. I got into this hobby almost a decade ago on a Prusa, I still run one today, and I have spent enough of my career writing software to have a strong and specific reaction to this. It is not a political one. It is an engineering one. The bill asks for a piece of software that cannot reliably exist, and even if it could, it would have nowhere to run. On top of that imaginary foundation it then builds an entire regulatory apparatus.

What AB2047 Actually Asks For

The mechanics are worth understanding before we argue about them. The bill lays out a multi-year timeline. By July 2027, the California Department of Justice studies firearm detection technology. By January 2028, it certifies detection algorithms from vendors. By July 2028, manufacturers must submit an attestation for each printer model they sell. By September 2028, the state publishes a list of approved printers, updated quarterly. And starting in March 2029, selling a non-compliant printer in California becomes illegal. There are new criminal penalties for anyone who disables the detection technology.

Read that sequence again and notice what it assumes. It assumes that by 2028 there will be vendors selling reliable firearm-detection software, that the DOJ will be able to certify it, and that manufacturers can bolt it onto their machines. The entire structure depends on step one being possible. So let’s look at step one.

A Rifled Barrel Is Just a Grooved Cylinder

Here is the core problem, and it is the kind of thing that sounds solvable until you actually try to specify it. A 3D printer receives a model. The model is geometry: a mesh of triangles, sliced into a stack of two-dimensional paths. To detect a firearm part, the software would have to look at that geometry and decide whether it represents something dangerous.

But geometry does not carry intent. A rifled barrel, to a detection algorithm, is a grooved cylinder. So is a section of industrial screw thread. So is part of an optical instrument, a custom gear, a textile bobbin, a printable fidget toy, a thousand legitimate objects. The shape that makes a barrel a barrel is not unique to barrels. You cannot write a function that takes in a mesh and returns “this is a gun part” without either missing real firearm components or flagging an enormous number of innocent ones. In machine learning terms you are choosing between false negatives and false positives, and both failure modes here are catastrophic. Miss the real thing and the law accomplishes nothing. Flag the innocent thing and you have a printer that refuses to make a curtain rod bracket because it looks suspicious.

It gets worse once you remember that the person trying to evade detection gets a vote. Shape-based detection is defeated by the most trivial transformations imaginable. Rotate the model. Scale it slightly. Split a banned object into a handful of innocent-looking pieces, print them across separate jobs, and assemble them on the bench, which is how people print large or complex parts anyway. None of these change the function of the final object, and all of them defeat a classifier looking for a known silhouette. There is an old locksmith’s adage that locks only keep honest people honest. A detection algorithm is a kind of lock, and this one stops the honest while inconveniencing nobody who is actually a threat.

Where Would This Software Even Run

Suppose, against all of this, that someone ships a detection algorithm that actually works. There is a second wall waiting behind the first, and it is the part of this I find almost funny: even a perfect classifier would have nowhere to run.

Here is what most people, and I suspect most legislators, do not realize about how these machines work. By the time a design reaches my printer, it is no longer a 3D model. Software on my computer, called a slicer, has already flattened it into G-code, a dumb list of hundreds of thousands of instructions that say move here, extrude this much, heat to this temperature. The printer’s control board never sees the shape of the object at all. For the firmware on the printer to detect a gun, it would have to reconstruct a three-dimensional model out of raw toolpaths and run shape analysis on it, on a microcontroller with kilobytes of memory. My Prusa cannot do that. No consumer printer can. It is not a hard engineering problem so much as an absurd one.

So the detection has to live somewhere else, and there are really only two places it can go. The first is the slicer. But the popular slicers, PrusaSlicer, Cura, OrcaSlicer, are themselves open source. You fork the one with the block stripped out, or you simply use a different one, and nothing downstream ever checks what it produced. The second place is the only one that actually enforces anything: require every printer to refuse any G-code that is not cryptographically signed by a state-approved cloud slicing service. That version works, in the narrow sense that it would function. It also means the end of slicing your own files on your own computer, the end of open-source firmware, the end of the printer as a general-purpose tool. It turns an open machine into a locked appliance that prints only what a government-approved server allows.

That is the choice the bill quietly forces, even if its authors never say it out loud. Either the detection is real and trivially bypassed, or it is genuinely enforceable and the open ecosystem is dead.

And that open ecosystem is not incidental to how these machines work. The software that actually drives them, the two dominant projects Marlin and Klipper, is open source and free to download, and replacing the firmware on a printer is something the community does routinely, in minutes, to tune machines and add features. A state-mandated block sitting in that firmware is removable by definition. The whole community already holds the key to the proposed lock. The law is betting that criminals either do not know the key exists or will politely decline to use it. The bill’s response is criminal penalties for disabling the technology, which means the actual enforceable result is that an ordinary maker who updates their firmware becomes a potential criminal, while anyone with bad intent was always going to use a non-compliant machine bought out of state or built from parts.

Who Actually Pays

This is where the abstract engineering critique becomes a real-world one. The signatories on the opposition letter are not a fringe group. They include Prusa Research, Make Magazine, and VORON Design, alongside individuals like Josef Průša, Dale Dougherty, and Joel Telling of 3D Printing Nerd. The numbers they cite are the reason. More than 1.5 million California students reach 3D printing through their schools. More than 30,000 businesses depend on it, from dental labs to jewelers to small manufacturers. There is something on the order of $10.5 billion in investment riding on this ecosystem in the state.

The bill’s penalties, reportedly $25,000 per violation, do not land on the people it is nominally aimed at. They land on the school district, the maker space, the library, the small business owner running three printers in a garage. Those are the entities that buy from compliant vendors, register their equipment, and follow the rules. The person determined to manufacture an untraceable weapon was never in that group. They route around the law, because routing around the law is, as we just established, trivial. So you end up with the worst possible outcome: real cost imposed on the law-abiding, near-zero cost imposed on the dangerous, and a chilling effect on exactly the educational and small-business use that makes this technology worth having.

Compelled Speech and the First Amendment

There is a legal dimension I am less qualified to litigate but that I think any engineer should at least register. CAD files and the source code that drives these machines are, under a long line of cases, a form of protected expression. The bill requires manufacturers to attest to the behavior of an algorithm operating on that expression, which the opposition frames as compelled speech on a matter of public concern. I am not a lawyer, and I will not pretend the constitutional question is open and shut. But it should make us uncomfortable that the mechanism here is the state requiring a company to vouch for the output of detection software that, as far as anyone can demonstrate, does not actually work. Picture a law that required every typewriter manufacturer to certify, in writing and renewed every year, that their machines cannot be used to type a threatening letter. That is roughly the position AB2047 puts a printer company in. You are being compelled to attest to a fiction, under penalty.

What This Pattern Should Teach Us

I want to be careful here, because it is easy to read a piece like this as “no regulation, ever.” That is not my position. Untraceable firearms are a genuine problem and a serious one. The objection is not that the goal is illegitimate. The objection is that the proposed mechanism is engineering fan fiction, and that mandating impossible software does not become possible because a statute says so.

It helps to remember what the law already does. California does not ignore homemade firearms. If you want to build your own, you must first apply to the Department of Justice for a serial number and engrave it on the receiver, and doing otherwise is itself a crime. The state already regulates the dangerous act, directly, where it belongs. What AB2047 does instead is reach past the act and conscript the tool. Nobody expects Home Depot to interrogate why I am buying a length of steel pipe or a box of fasteners, even though plenty of dangerous things can be assembled from ordinary hardware. We regulate the act, not the hardware store, because the hardware store cannot read minds. Neither can my printer.

This is a pattern worth recognizing, because 3D printers are not the last general-purpose tool a legislature is going to try to make smart enough to police its own users. Any time a law says “the tool must detect bad use and refuse it,” an engineer should ask the boring, deflating questions. Can the tool actually distinguish intent from form? What does the determined adversary do in response? Who absorbs the cost when the detection is wrong? For AB2047 the answers are no, they trivially route around it, and the schools and makers do. When those are your answers, you do not have a safety feature. You have a tax on the honest and a piece of theater for everyone else.

If you build things, and especially if you build things in California, this one is worth paying attention to. The opposition letter has a breakdown of where the bill stands and who to contact on the Senate Judiciary and Public Safety committees before it advances. I am writing to those committee members, and I am going to call my own state senator, Dave Cortese, because the gap between what the bill asks for and what software can actually do is not a close call, and that gap is precisely the kind of thing the people who build these machines are in a position to explain.

My printer is still running as I finish this. It still has no idea what it is making. And no statute, however well-intentioned, is going to change that.

A futuristic glowing notebook on a wooden desk with a cup of coffee and floating geometric shapes.

Reading List 6

Allen HutchisonLeave a comment

This week’s reading list is a mix of high-level theory and low-level pragmatism. I found myself bouncing between the philosophical implications of how we build AI and the immediate satisfaction of writing a good Go component.

[article] The Century-Long Pause in Fundamental Physics. The author argues that physics has stagnated by swapping “ontology-first” theory for mathematical models that merely fit data. This debate perfectly mirrors current machine learning disputes about whether LLMs build internal world models or just pattern-match at scale, which is the open empirical front currently being adjudicated in mechanistic interpretability.

[release] Onyx Has Released a New Remote Page Turner Called Tappy. I wish Amazon would support page turners for their Kindle line. It would be great if they supported a device as delightful as this one.

[blog] The agent principal-agent problem. This is a great look at one of the biggest problems with agentic development: code review. In my open source work, I now use a pattern where I work with an agent to make a change, test it locally, and create a pull request before having another agent review the code. This back-and-forth works well and keeps a good balance of mental state for the codebase and efficiency.

[article] ReMarkable Paper Pure wants to be the only notebook you’ll ever need. I have always liked the reMarkable tablets, but every time I try one I miss having my Kindle library alongside it. Reading and writing are deeply linked for me, which is why I recently got a Kindle Scribe Colorsoft and found it really hits the mark for what I want.

[blog] Just Fucking Use Go. I have been working on a project that has a Go component to it recently. This is the first time I have really started to look at the language, and it inspires me to spend more time with it.

I built my 7MB Full AI Terminal in Rust & Tauri. This is a neat open source AI terminal. It feels similar to Warp but is a lot smaller.

[article] Computer Use Is 45x More Expensive Than Structured APIs. I am not surprised at all by these findings. I think computer use will remain a last resort, and a lot of apps will expose some kind of API for an agent to use instead. My guess is that this eventually becomes the way we automate unmaintained applications that need to fit into an agentic workflow.

A bird's-eye view of a winding river of glowing green GitHub contribution tiles flowing across a dark landscape, with bright yellow-green flames rising from clusters of the brightest tiles, while a lone figure sits at a laptop at the edge of the mosaic under a distant skyline of code-filled windows.

4255 Contributions – A Year of Building in the Open

Allen Hutchison5 Comments

I was staring at my GitHub profile the other day when a number caught my eye. 4,255. That’s how many contributions GitHub has recorded for me over the past year. I sat with it for a moment, doing the quick mental math: that’s close to twelve contributions every single day, weekends included. The shape of the year looked just as striking. I showed up on 332 of the 366 days in the window, 91% of them, and at one point put together a 113-day streak without a gap. It felt like a lot. It felt like proof of something I hadn’t been able to articulate until I saw it rendered as a green heatmap on a screen.

About a year ago, I wrote about my decision to move back to individual contributor work after years in leadership roles. I talked about missing the flow state, the direct feedback loop of writing code and watching it work. What I didn’t know at the time was just how dramatically that shift would show up in the data. 4,255 contributions is the quantitative answer to the question I was trying to answer qualitatively in that post: what happens when you give a builder back the time to build?

The Shape of a Year

Numbers by themselves are just numbers. What makes them interesting is the shape they take when you zoom in. My year wasn’t a single monolithic effort on one project. It was a constellation of interconnected work, each project feeding into the next, each one teaching me something that made the others better.

The largest body of work was on Gemini CLI, Google’s open-source AI agent for the terminal. This project alone accounts for a significant chunk of those contributions, spanning everything from core feature development to building the Policy Engine that governs how the agent interacts with your system. But the contributions weren’t just code. A huge portion of my time went into code reviews, issue triage, and community engagement. Working on a repository with over 100,000 stars means that every merged PR has real impact, and every review is a conversation with developers around the world.

Then there was Gemini Scribe, my Obsidian plugin that started as a weekend experiment and grew into a tool with 302 stars and a community of writers who depend on it. Over the past year, I shipped a major 3.0 release, built agent mode, and iterated constantly on the rewrite features that make it useful for daily writing. In fact, this very blog post was drafted in the tool I built, which is a strange and satisfying loop.

Alongside these larger efforts, I shipped a handful of small, sharp tools that I needed for my own workflows. The GitHub Activity Reporter is one I’ve written about before, a utility that uses AI to transform raw GitHub data into narrative summaries for performance reviews and personal reflection. More recently, I built the Workspace extension for Gemini CLI and a deep research extension that lets you conduct multi-step research from the terminal. Each of these tools was born from a specific itch, and each turned out to be useful to more people than I expected. The Workspace extension alone has gathered 510 stars.

The Rhythm of Building

One thing the contribution graph doesn’t capture is the rhythm behind the numbers. My weeks developed a cadence over the year that I didn’t plan but that emerged naturally. Mornings were for deep work on Gemini CLI, the kind of focused system design and implementation that benefits from a fresh mind. Afternoons were for reviews and community work, responding to issues, providing feedback on PRs, and engaging with the developers building on top of our tools. Evenings and weekends were where the personal projects lived: Gemini Scribe, the extensions, and whatever new idea was rattling around in my head.

This rhythm is something I couldn’t have had in my previous role. When your calendar is stacked with meetings from nine to five, the creative work gets squeezed into the margins. Now, the creative work is the whole page. That’s the real story behind 4,255 contributions. It’s not about productivity metrics or GitHub gamification. It’s about what happens when you align your time with the work that energizes you.

What Surprised Me

A few things caught me off guard when I looked back at the year.

First, the ratio of code to “everything else” wasn’t what I expected. I assumed the majority of my contributions would be commits. In reality, a massive portion was reviews, comments, and issue management. On Gemini CLI alone I logged 205 reviews over the year. This was especially true as my role on that project evolved from pure contributor to something closer to a technical steward. Reviewing a complex PR, asking the right questions, and helping someone refine their approach takes just as much skill as writing the code yourself. Sometimes more.

Second, the personal projects had more reach than I anticipated. When I wrote about building personal software, I was mostly thinking about tools I built for myself. But Gemini Scribe has real users who file real bugs and request real features. The Workspace extension took off because it solved a problem that a lot of Gemini CLI users were hitting. Building in the open means you discover an audience you didn’t know was there.

Third, and this is the one I keep coming back to, the year felt shorter than 4,255 contributions would suggest. Flow state compresses time. When you’re deep in a problem, hours feel like minutes. I remember entire weekends spent in the codebase that felt like an afternoon. That compression is, for me, the clearest signal that I made the right call in going back to IC work.

Fourth, and this is the one I never would have predicted until I charted it out: the weekend, not the weekday, turned out to be my most productive window by a wide margin. Saturdays averaged 14.7 contributions, Sundays 14.5, and Thursday, the day I’d have guessed was safest, came in last at 8.3. The busiest single day of the entire year was a Saturday, December 20, when I shipped 89 contributions into podcast-rag, rebuilding the web upload flow, adding episode management to the admin dashboard, and migrating email delivery over to Resend, all in one afternoon. I didn’t plan for the weekends to become the engine. They just did, because that’s where the personal projects live, and the personal projects are where the work is loudest, most direct, and most free of interruption. A day with no meetings on it, I’ve come to realize, is worth more than I ever gave it credit for.

Looking Forward

I don’t know what next year’s number will be, and I’m not particularly interested in making it bigger. The number is a side effect, not a goal. What I care about is continuing to work on problems that matter, in the open, with people who push me to think more clearly. The AI-first developer model I wrote about over a year ago is now just how I work every day. The agents I’m building are the collaborators I’m building with, and both keep getting better.

If you’re someone who’s been thinking about a similar shift, whether it’s moving back to IC work, contributing to open source, or just carving out more time for the work that lights you up, I’d encourage you to try it. You might be surprised by what a year of focused building can produce. I certainly was.

A cheerful, cartoon-style purple bear with a large head and big eyes is sitting at a desk, happily using a computer with a text editor open on the screen. A section of the text is highlighted.

A More Precise Way to Rewrite in Gemini Scribe

Allen HutchisonLeave a comment

I’ve been remiss in posting updates, but I wanted to take a moment to highlight a significant enhancement to Gemini Scribe that streamlines the writing and editing process: the selection-based rewrite feature. This powerful tool replaced the previous full-file rewrite functionality, offering a more precise, intuitive, and safer way to collaborate with AI on your documents.

What’s New?

Instead of rewriting an entire file, you can now select any portion of your text and have the AI rewrite just that part based on your instructions. Whether you need to make a paragraph more concise, fix grammar in a sentence, or change the tone of a section, this new feature gives you surgical precision.

How It Works

Using the new feature is simple:

  1. Select the text you want to rewrite in your editor.
  2. Right-click on the selection and choose “Rewrite with Gemini” from the context menu, or trigger the command from the command palette.
  3. A dialog will appear showing you the selected text and asking for your instructions.
  4. Type in what you want to change (e.g., “make this more formal,” “simplify this concept,” or “fix spelling and grammar”), and the AI will get to work.
  5. The selected text is then replaced with the AI-generated version, while the rest of your document remains untouched.

Behind the scenes, the plugin sends the full content of your note to the AI for context, with special markers indicating the selected portion. This allows the AI to maintain the style, tone, and flow of your document, ensuring the rewritten text fits in seamlessly.

Why This is Better

The previous rewrite feature was an all-or-nothing affair, which could sometimes lead to unexpected changes or loss of content. This new selection-based approach is a major improvement for several reasons:

  • Precision and Control: You have complete control over what gets rewritten, down to a single word.
  • Safety: There’s no risk of accidentally overwriting parts of your document you wanted to keep.
  • Iterative Workflow: It encourages a more iterative and collaborative workflow. You can refine your document section by section, making small, incremental improvements.
  • Speed and Efficiency: It’s much faster to rewrite a small selection than an entire document, making the process more interactive and fluid.

This new feature is designed to feel like a natural extension of the editing process, making AI-assisted writing more of a partnership.

A Note on the ‘Rewrite’ Checkbox

I’ve received some feedback about the removal of the “rewrite” checkbox from the normal mode. I want to thank you for that feedback and address it directly. There are a couple of key reasons why I decided to remove this feature in favor of the new selection-based rewriting.

First, I found it difficult to get predictable results with the old mechanism. The model would sometimes overwrite the entire file unexpectedly, which made the feature unreliable and risky to use. I personally rarely used it for this reason.

Second, the new Agent Mode provides a much more reliable way to replicate the old functionality. If you want to rewrite an entire file, you can simply add the file to your Agent session and describe the changes you want the AI to make. The Agent will then edit the entire file for you, giving you a more controlled and predictable outcome.

While I understand that change can be disruptive, I’m confident that the new selection-based rewriting and the Agent Mode offer a superior and safer experience. I’m always looking for ways to improve the plugin, so please continue to share your thoughts and feedback on how you’re using the new features.

The Future is Agent-ic

Ultimately, over the next several iterations of Gemini Scribe, I’ll be moving more and more functionality to the Agent Mode and merging the experience from the existing Gemini Chat Mode into the Agent. I’m hoping that this addresses a lot of feedback I’ve received over the last nine months for this plugin and creates something that is even more powerful for interacting with your notes. More on Agent Mode in a coming post.

I’m really excited about this new direction for Gemini Scribe, and I believe it will make the plugin an even more powerful tool for writers and note-takers. Please give it a try and let me know what you think!

Gemini Scribe Supercharged: A Faster, More Powerful Workflow Awaits

Allen HutchisonLeave a comment

It’s been a little while since I last wrote about Gemini Scribe, and that’s because I’ve been deep in the guts of the plugin, tearing things apart and putting them back together in ways that make the whole experience faster, smoother, and just plain better.

One of the first things that pushed me back into the code was the rhythm of the interaction itself. Every time I typed a prompt and hit enter, I found myself waiting—watching the spinner, watching the time pass, watching the thought in my head cool off while the AI gathered its response. It didn’t feel like a conversation. It felt like submitting a form.

That’s fixed now. As of version 2.2.0, Gemini Scribe streams responses in real-time. You see the words as they’re generated, line by line, without the long pause in between. It makes a difference. The back-and-forth becomes more fluid, more natural. It pulls you into the interaction rather than holding you at arm’s length. And once I started using it this way, I couldn’t go back.

But speed was only part of it. I also wanted more control. I’ve been using custom prompts more and more in my own workflow—not just as one-off instructions, but as reusable templates for different kinds of writing tasks. And the old prompt system, while functional, wasn’t built for that kind of use.

So I rewrote it.

Version 3.0.0 introduces a completely revamped custom prompt system. You can now create and manage your prompts right from the Command Palette. That means no more hunting through settings or copying from other notes—just hit the hotkey, type what you need, and move on. Prompts are now tracked in your chat history too, so you can always see exactly what triggered a particular response. It’s a small thing, but it brings a kind of transparency to the process that I’ve found surprisingly useful.

All of this is sitting on top of a much sturdier foundation than before. A lot of the internal work in these recent releases has been about making Gemini Scribe more stable and more integrated with the rest of the Obsidian ecosystem. Instead of relying on low-level file operations, the plugin now uses the official Obsidian APIs for everything. That shift makes it more compatible with other plugins and more resilient overall. The migration from the old system happens automatically in the background—you shouldn’t even notice it, except in the way things just work better.

There’s also a new “Advanced Settings” panel for those who like to tinker. In version 3.1.0, I added dynamic model introspection, which means Gemini Scribe now knows what the model it’s talking to is actually capable of. If you’re using a Gemini model that supports temperature or top-p adjustments, the plugin will surface those controls and tune their ranges appropriately. Defaults are shown, sliders are adjusted per-model, and you get more precise control without the guesswork.

None of these changes happened overnight. They came out of weeks of using the plugin, noticing friction, and wondering how to make things feel lighter. I’ve also spent a fair bit of time fixing bugs, adding retry logic for occasional API hiccups, and sanding off the rough edges that show up only after hours of use. This version is faster, smarter, and more comfortable to live in.

There’s still more to come. Now that the architecture is solid and the foundation is in place, I’m starting to explore ways to make Gemini Scribe even more integrated with your notes—tighter context handling, more intelligent follow-ups, and better tools for shaping long-form writing. But that’s a story for another day.

For now, if you’ve been using Gemini Scribe, update to the latest version from the community plugins tab and try out the new features. And if you’ve got ideas, feedback, or just want to follow along as things evolve, come join the conversation on GitHub. I’d love to hear what you think.

Small tools, Big Ideas

Allen Hutchison4 Comments

It’s a strange time to love simple things. Everywhere I look, the future seems to be rushing toward bigger models, smarter systems, and more complex layers of automation. The story of modern technology is often told as a relentless climb toward more: more intelligence, more capability, more speed. And yet, in the quiet corners of my own work, I keep finding myself drawn back to something much older and simpler. A clean note in a vault. A script with a single, clear purpose. A search box that just works. These small tools, which once felt ordinary, now feel almost radical in their elegance. In a world where everything is getting smarter, I’m finding unexpected joy in the tools that stay beautifully dumb.

Lately, I’ve been thinking a lot about Simon Willison’s llm tool — a little Python utility that gives you a command-line interface for large language models. It doesn’t hide the complexity behind a thousand settings or a shiny UI. It just gives you a simple, direct line to the model, letting you wire it into your workflows however you want. His files-to-prompt tool is another one I admire: an almost absurdly minimal way to push files into a prompt template for LLMs. Both tools feel like reminders that power doesn’t have to mean complexity. Sometimes the most transformative tools are the ones that stay small, sharp, and focused.

This same idea keeps showing up for me in other places too. I’ve been spending more time with tmux lately — not a simple tool in the sense of being easy, but a simple one in its spirit. It doesn’t try to be clever or guess what I want. It gives me a set of building blocks: panes, sessions, terminals — and lets me compose my environment exactly how I like it. Once you internalize its grammar, you realize that you’re no longer fighting your tools. You’re building with them.

In my podcast RAG project, I’ve seen this play out with Whisper too. Whisper isn’t flashy. It’s a humble little engine that quietly turns audio into text, and the latest version is astonishingly good at it. I didn’t need to fine-tune it or coax it into working. I just pointed it at my podcast archive, and it got to work. And it kept working. There’s a kind of magic in that — a tool that doesn’t require worship or endless maintenance, just quiet trust.

The same feeling hit me again recently when I started using uv for Python package management. For years, Python developers have wrestled with slow installs, dependency conflicts, and the occasional cryptic error that turns a five-minute task into a two-hour rabbit hole. uv doesn’t try to paper over those problems with another layer of complexity — it just fixes them. Installs are blindingly fast. Dependency resolution is smart and sane. Virtual environments are first-class citizens, not an afterthought. Using it feels like someone finally rebuilt the foundation without adding a skyscraper on top. It’s one of those tools that makes you wonder how you ever put up with the old way.

Then there’s Ollama, which has completely changed the way I think about local models. Before Ollama, running large language models yourself meant a tangle of Docker containers, custom scripts, GPU configurations, and crossed fingers. Now? You run ollama run, and you’re talking to a model. It’s almost unsettling how easy they’ve made it — not because they hid the power, but because they made a conscious choice to minimize the friction.

And finally, I can’t talk about this new season of rediscovery without mentioning Ghostty. Since it was released in December, Ghostty has become my daily driver for terminals. It doesn’t try to reinvent what a terminal is; it just fixes all the little things that made older terminals frustrating, and it does it with style. Fast, beautiful, reliable. It feels like someone finally sat down and asked: what if we just made this delightful?

When I step back and look at all of these tools — the tiny Python scripts, the old-school multiplexers, the whisper-quiet transcription engines, the frictionless model runners, the sleek terminals, the rebuilt package managers — I realize they all share something in common. They don’t try to be everything. They aren’t built around a fantasy of replacing me. They’re built around the idea of empowering me.

Maybe that’s the real story happening quietly in the margins of our AI-first world.

It’s not just about building bigger models or smarter systems. It’s about rebuilding the foundations — making the tools that carry us forward simpler, faster, sturdier. Tools that invite us to stay close to the work, instead of drifting away from it.

The future won’t be built by magic.

It will be built by people who still care about the foundations.