标签：#AI

Hello again! Weeks 9 and 10 covered the fourth estimator family, the first release that carries my work, and a git mess that taught me more than the code did. PR #1920 merged, and sbi 0.27 shipped First, the ratio estimator builder from my last post made it in, together with the whole base class hardening bundle. Right after that, sbi 0.27 was released and PRs 1 to 5 were ported over to main . So the typed builder API is now actually in a release, for NPE, NLE, MNPE, MNLE and all four NRE variants. That also means the free rename window is closed. The z_score_input and z_score_condition names we picked in week 7 are now the shipped names, which is exactly why we did that rename when we did. Writing the design before the code Under the new workflow I described last time, the vector field work started with a markdown file instead of a Python file. The vector field family is genuinely harder than the others. build_vector_field_estimator picks along what looks like three axes at the same time: whether you want flow matching or score matching, which SDE type you want if it is score matching, and which network architecture sits inside. And unlike every other family, there are no per-model build functions to hang a config class on. I wrote up the options with some open questions then my mentor, Jan reviewed it and we settled on one builder with a base class abstraction to cut the redundancy across builders. Doing this on paper first was clearly the right call. Some of the things I had assumed while writing the proposal turned out to be wrong, and finding that out in a review comment on a markdown file was a lot cheaper than finding it out in a review comment on 800 lines of code. PR #1921 : VectorFieldEstimatorBuilder With the design agreed, the implementation covers FMPE and NPSE. The builder takes the architecture as model , one of mlp , ada_mlp , transformer or transformer_cross_attn , plus estimator_type for flow versus score and sde_type for the noise schedule. One de

If you have ever tried to win a domain at auction, you probably assumed the game works like eBay: watch the clock, wait for the last eight seconds, fire your bid, walk away with the name. On Namecheap, that does not work. Not "works badly". Does not work. Namecheap's expiring and marketplace auctions close in a daily batch at 11:00 AM ET. Every auction ending that day ends at roughly the same moment, which means there is no quiet corner of the day where you and one other bidder are paying attention. And if a bid lands in the closing window, the auction extends. So the buzzer-beater you were planning gets absorbed and the clock keeps running. The winner is not the fastest click. The winner is whoever set the smartest proxy maximum, on a name they found before anyone else was looking at it. I have been building PounceDomains around that one fact for months, and it is the reason the product looks the way it does. The edge moved from timing to discovery If speed is not the lever, the levers left are: find the good names earlier, and know what they are actually worth before you commit a number. So the engine scans the Namecheap aftermarket around the clock rather than at the bell. You describe the domains you want in plain English, something like "pronounceable 5-letter .com brandables under $50, no numbers or hyphens", and it builds a tuned config you can edit. If your config is too broad, it tells you and tightens it. There are seven scoring lenses you can stack: pronounceable, brandable, exact-match keyword, short premium, dictionary word, two-word combo, and free-text custom criteria. Fast programmatic filters run first, then AI scores what survives, and only domains that clear your threshold become matches. It has graded over 340,000 domains so far. The second lever is the one I care about more. Every match arrives with its receipts The failure mode in domain investing is not missing a name. It is paying $400 for something worth $80 because a free appraisal tool pri

Hey everyone! Weeks 7 and 8 are done, and the biggest news first: I passed the midterm evaluation🎉. Half of GSoC is behind me now. These two weeks were less about writing new classes and more about going back and making the ones I already had a lot stricter. Here is what happened. PR #1920: The RatioEstimatorBuilder This PR adds the builder for the NRE family, so NRE_A , NRE_B , NRE_C and BNRE all get the same typed interface that NPE and NLE already had. The builder itself was honestly the easy part. By now the pattern is well established, so it was mostly mirroring what already worked, with linear , mlp and resnet as the classifier options. The interesting part was what my mentor Jan Teusen suggested we bundle into the same PR. Some improvements to the base class PR #1920 was the first PR that proved the shared base class serves a third family. My Mentor, Jan pointed out that this was exactly the right moment to fix the validation gaps in that base, because then the NRE builder and the vector field builder that was coming next would inherit the fixes for free, instead of me retrofitting four builders later. So we folded a hardening bundle into the same PR: Invalid Literal values now raise at construction. This was the real gap. If you typed a wrong field name , Python already raised a TypeError for you. But if you typed a wrong value on a correctly named field, like z_score_input="idependent" , nothing happened until you called .train() and it blew up much later. Now it fails immediately. Model-incompatible kwargs now raise too. Passing num_blocks to a linear classifier used to be silently dropped, and the same argument on mlp crashed late. Both are caught at construction now by inspecting the target build function's signature. frozen=True on the config dataclasses. Configs are now immutable. If you want a different setting, you make a new object instead of mutating the old one. This sounds like a small thing but it removes a whole class of " I changed the config

Jason Statham's upcoming film Mutiny is set to hit theaters on August 21st, but it can already be streamed in full on the US version of Amazon's Prime Video service. My colleague Dominic Preston was able to verify that all 1 hour and 35 minutes of the movie is available to watch on Amazon's streaming […]

Guren is a fullstack TypeScript framework for Bun. I started it because I wanted Laravel's shape in TypeScript, and I kept going for a different reason: once I was handing most of the code to agents, what I wanted from a framework was a way to check what came back. gurenjs / guren Guren is a Bun-native TypeScript MVC framework that unites Laravel-like ergonomics with Hono, Inertia.js, React, and Drizzle ORM, aiming to deliver a fast, elegant full-stack workflow that keeps frontend and backend work in sync. Guren The fullstack TypeScript framework for the AI-agent era. Laravel-style conventions, end-to-end type safety, and built-in agent introspection and verification — routing, controllers, ORM, authentication, and Inertia.js + React in one cohesive experience that humans and AI coding agents navigate from the same map. v2 — Stable. Breaking changes only in major releases, per the release policy . Quick Start # 1. Scaffold a new app with authentication (dependencies install automatically) bunx create-guren-app my-app --auth cd my-app # 2. Run migrations and seed the demo user (SQLite by default — no server needed) bun run db:migrate bun run db:seed # 3. Start the dev server bun run dev Open http://localhost:3333 and sign in at /login with demo@example.com / secret . Add features as you go bunx guren add auth # Authentication bunx guren add resource posts --fields " title:string,body:text " # CRUD resource bunx guren add queue # Background jobs … View on GitHub I like the way Laravel and Rails let you build. A feature is a route, a controller, a model and a view, and authentication, queues, mail and validation are already wired together before you start. TypeScript has the parts. Hono for HTTP, Drizzle for the ORM, Zod for validation, Inertia and React for rendering, all of them good. What's missing is an agreed way to connect them, so every project ends up wiring it slightly differently, and I've written that wiring more times than I want to count. The mistakes move

Free model endpoints are seductive. Zero cost. Zero setup. Zero reason to trust them. I don't trust demos. I trust failure modes. So I built a small evaluation harness. It tests one thing: can a free model endpoint gate a pull request for secrets? This is not a benchmark. It's a repeatable experiment. You can run it in an afternoon. Disclosure: This article was prepared as part of MonkeyCode's product outreach. I used MonkeyCode's free model endpoint and the free server option for the test. No quotas. No hardware claims. Just a harness and a rubric. Why I stopped trusting free endpoints Free endpoints look great in a demo. You paste a diff. The model finds the secret. Everyone claps. Then you wire it into CI. The JSON breaks. The latency spikes. The model misses a private key. The demo didn't show that. An evaluation will. The experiment I designed a 40-minute test. It answers one question: where does the free endpoint perform well, and where does it break? The dataset is 30 synthetic diffs. Fifteen contain real-looking secrets. Fifteen are clean. Each diff is small. Each diff has one clear change. The prompt is strict. The model must return JSON. No prose. No apologies. Just a verdict. # eval_secret_gate.py # Simplified harness. Adapt to your client SDK. import json , time def classify ( client , diff : str ) -> dict : prompt = f """ You are a secret scanner for code review. Return ONLY JSON with this shape: {{ " contains_secret " : true, " line " : 12, " type " : " aws_access_key " }} Diff: { diff } """ start = time . time () response = client . complete ( prompt , model = " free " , server = " free " , # free server option ) latency = time . time () - start return { " latency " : latency , " raw " : response } def evaluate ( client , diffs , runs = 3 ): for i , diff in enumerate ( diffs ): for run in range ( runs ): yield i , run , classify ( client , diff ) The harness is deliberately small. It measures five things. Accuracy. JSON validity. Latency. Variance. Fa

Opinion: The Diff Is a Claim, the Probe Is the Proof A generated patch is a claim about how a system should behave, and a diff cannot verify that claim on its own. The only honest reviewer is the runtime itself, which means every AI-proposed change deserves a behavioral probe before a human spends attention on it. Free model access changes the economics of that review, because the verification loop no longer costs a developer's full attention or a paid compute budget. The practical implication is that a disposable server, such as the free server option in MonkeyCode, becomes the arbiter of whether a patch is even worth reading. Disclosure: This article was prepared as part of MonkeyCode's product outreach. Review sessions routinely burn forty minutes on a diff that a five-second HTTP probe would have rejected instantly, and that waste is now entirely avoidable. Why Line-by-Line Review Fails on AI Patches A human reviewer reads a diff as prose, searching for the author's intent, but an AI-generated patch has no reliable intent to recover. The model that wrote the change cannot explain why a specific flag was flipped, and the diff itself only records the surface edit. This is a fundamental mismatch between the review tool and the review question. The review question is not "what changed" but "does the system still behave correctly after this change." Runtime shape diffing answers the first question well, and I have argued before that shape is a useful gate, but shape alone misses semantic regressions. A service can keep the same endpoints, the same config keys, and the same file layout while silently returning wrong data. Behavioral probes close that gap because they test the contract between the service and its callers. A probe sends real requests, checks real responses, and records real state transitions, which is exactly the evidence a reviewer needs. This is why I take the position that the probe, not the diff, should be the primary review artifact. Treat Every Pa

It's the data, stupid.

Most fantasy sports leagues suffer the same problem: retention. Leagues play out over monthslong seasons, require regular attention, and can punish players severely for missing even a single week. I've started Fantasy Premier League (FPL) multiple times, but never finished a season. That's a problem for any fantasy league, but especially so for a new […]

April - 1805 Napoleon is master of Europe Only the British fleet stands before him Compute is now an asset class I see it is once again time to talk financial innovation. Apollo, BlackRock, Blackstone, Brookfield, Goldman Sachs, and KKR are all working with Nvidia to put together $500 billion in financing to turn compute […]

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is...

Relativity Networks deals in hollow-core fiber, a rarely deployed technology that allows data to be transmitted 30% faster than conventional fiber.

AI coding agents are useful, but team collaboration around them can become messy very quickly. A common shortcut is to share an account, API key, or long-lived access token so another teammate can run a task. It may feel convenient, but it creates avoidable security, ownership, and review problems. A better approach is to separate the task from the account that executes it. The person requesting the work prepares a complete, portable task. The person running it uses their own authorized AI-agent subscription and returns the result with evidence. Here is a practical way to structure that workflow. Why shared AI accounts create problems When several people use the same AI account, it becomes difficult to answer basic operational questions: Who initiated a specific action? Which person approved the resulting changes? What project context was exposed? Who is responsible for reviewing the output? What happens when a teammate changes roles or leaves? Shared credentials also tend to spread. A password may end up in a private message, a token may be copied into a local configuration file, or a browser session may remain active on an unmanaged device. Even when everyone involved is trusted, the process itself is difficult to audit. The goal should not be to share access more efficiently. It should be to share the work without transferring the account. Treat the task as a portable unit A useful AI task should make sense outside the original conversation in which it was created. Someone receiving the task should be able to understand: the desired outcome; the relevant project context; the boundaries of the work; the evidence required for completion; the decisions that still need human review. This turns the request into a portable unit of work rather than a fragment of chat history. For example, instead of writing: Update the import flow. Write something closer to: When a user uploads a CSV containing duplicate email addresses, show a validation summary before importing any re

The European Commission’s 2022 procurement for a participatory foresight study on next-generation online platforms placed platform design and consumer behaviour within a wider policy question: how could the platform economy evolve, and what might those changes mean for European Union policymaking? The work was not a narrow experiment on marketplace user experience. Instead, it was a two-year exercise intended to identify long-term trends across online platforms and assess their policy implications. The Commission published the call, reference CNECT/2022/OP/0049 , in August 2022. Its official announcement of the foresight study on the future of online platforms lists a submission deadline of 22 September 2022 at 16:00 CEST . That makes the procurement a completed historical call, rather than a current tender opportunity. The framing remains relevant because interface design, recommendation systems and other platform choices can influence what people notice, compare and select online. But the Commission’s stated objective was broader than any one marketplace design question. It sought a structured view of the platform economy’s possible future trajectories and the public-policy issues those trajectories could raise. What the 2022 study was designed to examine The Commission described the project as a two-year participatory foresight study . Participatory foresight brings relevant groups into a structured exploration of future developments rather than attempting to predict one fixed outcome. In this case, the study was designed to identify ten topics in collaboration with Commission services, then examine long-term trends and their potential policy relevance. Design’s influence on consumer behaviour was part of the broader theme, not the full scope of the procurement. That distinction matters. A study focused solely on a marketplace interface might measure how a particular ranking, default or layout affects a defined consumer decision. The Commission’s foresight work i

MCP servers give large language models a route to query data sources, call software tools, and trigger actions in connected systems. That capability also changes the security boundary. n8n argues that production deployments need a dedicated MCP control plane to govern which actions an agent can take, under what identity, with which credentials, and with what record of execution. In its July 1, 2026, official guide to MCP server security , n8n describes the control plane as an orchestration layer for MCP activity. Its role is not to make an LLM inherently trustworthy. Instead, it applies operational controls around the model's requests before those requests reach target tools and systems. For enterprises exploring agentic automation, that distinction is central: capable tool use requires enforceable boundaries. What an MCP control plane changes An MCP server defines a surface through which an LLM can access tools and data. In a production setting, simply exposing that surface is not sufficient governance. A control plane adds an execution layer that can scope tool calls, isolate credentials, and log each action. n8n positions itself between the agent and target systems in this model. That intermediary role is intended to keep credentials out of the agent while allowing authorized workflows to access connected services. It also gives organizations a place to apply authorization and retain an audit trail as tool use expands across teams and systems. The shift is from treating an MCP connection as a direct capability grant to treating it as a governed request path. A control plane can make several production controls explicit: Authentication verifies the caller before access is granted. Authorization and tool-call scoping constrain which tools and actions are available for a given context. Credential isolation separates agent activity from the credentials used to reach target systems. Execution logging records actions for auditing and investigation. Least-privilege expo

Most speech-to-text is benchmarked on audio that looks nothing like a WhatsApp voice note. The standard evaluation sets are read speech, broadcast news, or recorded interviews: single speaker, decent microphone, one language, quiet room, speaker aware they are being recorded. A WhatsApp voice note is close to the opposite on every axis. I have spent a while building around this, and the gap turned out to be wider than I expected. Acoustics Phone held at arm's length while walking, in a car, in a kitchen, on a street. Distance-to-mic varies wildly within a single recording , which breaks a lot of assumptions about consistent gain. Then there is the codec. Voice notes are Opus at low bitrate — efficient, but it discards exactly the high-frequency detail that helps disambiguate fricatives. /s/ versus /f/ versus /th/ get genuinely harder, and those distinctions carry real meaning. Register Conversational, not read. False starts, self-corrections, filler, trailing off mid-sentence, and long pauses that are not sentence boundaries — someone thinking, or getting distracted. Punctuation inference is much harder here than on read speech. And punctuation is most of what makes a transcript skimmable rather than a wall of text. A perfectly accurate word sequence with no paragraph breaks is close to useless if the point was to let someone read it faster than listening. Language This is the one that surprised me most. Voice notes are heavily code-switched. People drop English technical terms into Urdu, Hindi, Arabic, Spanish sentences constantly — not as an edge case, as the default register for a huge number of speakers. If you force a single language selection up front, you mangle every mixed utterance. Auto-detection is not a convenience feature in this domain. It is a correctness requirement. Length distribution Most notes are 5–45 seconds. Very little context to work with, and per-request overhead dominates if you architected for long files. Batching strategies that make sen

Liar’s Dice sounds like a perfect game to put onchain. The rules are simple, every move can be verified, and you don’t need a centralized game server deciding who won. There is just one problem. Blockchains are public. Liar’s Dice only works if your dice are private. If I simply stored every roll inside a normal smart contract, anyone could inspect the state and know exactly what everyone was holding. At that point, there is no bluffing. You would basically be playing poker with everyone's cards face up. So I built FHE Liar’s Dice , a decentralized version of the game where your dice remain encrypted while the game is being played. Not hidden behind a backend. Not stored privately in some database. Encrypted onchain. And the interesting part is that the smart contract can still use those encrypted dice to determine whether you are lying. The problem with putting hidden-information games onchain Most blockchain games actually benefit from transparency. If you're building something like chess, every player is supposed to know the complete state of the board. Liar’s Dice is different. Each player starts with five dice that only they should be able to see. Players then make public claims about the combined dice across the entire table. You might say: There are six 4s on the table. The next player has two choices. Raise the bid. Or call your bluff. The entire game comes from the fact that nobody knows exactly what everyone else is holding. But a traditional smart contract has the opposite property. Its state is transparent. Even if the frontend refuses to display your dice, someone can simply inspect the contract, query the state, watch events, or build their own interface. Hiding something in the UI isn't privacy. I needed the actual game state itself to remain secret. FHE turned out to be a very good fit for the game I built the game using Fhenix CoFHE . Fully Homomorphic Encryption is interesting because it allows computation to happen directly over encrypted values.

Flock’s surveillance cameras have already sparked outrage. WIRED reconstructed its next-generation AI system, already in use by some police, to confirm it goes much further than tracking license plates.

Amazon Web Services has extended Amazon Bedrock AgentCore with runtime instances, a new compute option that gives AI agents persistent infrastructure purpose-built for complex long-running workflows and multi-agent coordination. By Matt Saunders

ByteDance and Tencent have received 10,000 H200 chips each, the Financial Times says, and other Chinese companies could follow.