Details about the OpenAI Bio Bounty program

More intelligence from every token, stronger performance per dollar, and more capability on demand for your hardest work.

Un’area interna che sembra una lavagna di ragionamento: non è coscienza, ma è un indizio forte su come emergono controllo e pianificazione nei transformer. Negli ultimi anni ci siamo abituati a pensare ai modelli linguistici come a enormi “scatole nere”: un prompt entra, un testo esce, e nel mezzo c’è un mare di matrici difficili da ispezionare. Ma c’è una novità interessante: alcune analisi suggeriscono l’esistenza di una piccola regione interna, relativamente organizzata, che funziona come uno spazio di lavoro per concetti . Un posto dove il modello “tiene a mente” qualcosa prima di produrre la risposta. È un’idea che fa scattare subito l’associazione più pericolosa (e più abusata) del momento: coscienza . In realtà, il punto non è stabilire se un LLM sia cosciente; il punto è molto più concreto e utile per chi sviluppa: se esiste un’area interna che concentra il ragionamento controllabile , allora possiamo capire meglio cosa guida certe risposte e come intervenire su errori, allucinazioni e comportamenti indesiderati. J-Space: una “lavagna” interna per il ragionamento L’idea chiave è questa: dentro il modello emergerebbe un piccolo insieme di pattern neurali “coerenti” (chiamiamoli J-Space ) che si comporta come una lavagna. Su questa lavagna compaiono concetti (non necessariamente parole che verranno stampate). Questi concetti influenzano la catena di ragionamento . Molte altre abilità—fluency, grammatica, stile, completamento locale—sembrano invece scorrere “automaticamente” altrove. Se questa separazione regge, spiega un fenomeno che tutti abbiamo osservato: modelli capaci di scrivere in modo impeccabile, ma fragili nel ragionamento o incoerenti quando devono mantenere vincoli. Il test più interessante: sostituire un concetto e vedere il ragionamento obbedire Un esperimento illuminante consiste nell’individuare un concetto attivo nello spazio di lavoro e sostituirlo con un altro, senza cambiare né prompt né output manualmente. Esempio (semplificato): Domanda:

When an AI API call fails, the tempting reaction is to switch models or providers. That is often premature. A large share of 401, 429, model_not_found, timeout, and confusing billing issues are not model-quality problems. They are route-evidence problems. The request moved through a key, base URL, model ID, retry rule, fallback path, and billing record. If those pieces are not visible, changing the model can hide the real cause. Before you replace the model, debug the route. A practical route checklist Confirm the key scope. Is the API key attached to the right project, environment, and quota rule? A key that works in one workspace can fail in another because the limit, budget, or allowed model set is different. Confirm the base URL. Many OpenAI-compatible errors start with a request going to the wrong host, version path, or proxy. Check the exact Base URL used by the client, not the one written in a README from memory. Confirm the model ID. A model_not_found error is not always a provider outage. It can be a copied alias, a retired ID, a route that does not support that model, or a mismatch between public model names and API model IDs. Separate 401, 403, 404, and 429. These errors ask different questions: 401: is the key present and valid? 403: is the key allowed to use this route or model? 404/model_not_found: is the exact model ID available on this route? 429: is the limit coming from the user, key, project, provider, retry loop, or budget rule? Treating all of them as provider instability wastes time. Look for retry and fallback behavior. A single user action may trigger more than one model call. Agents, RAG pipelines, streaming clients, and SDK retries can quietly multiply traffic. If fallback is enabled, the served route may differ from the requested model. Check the usage and charge record. A successful response is not the end of the test. You should be able to explain which key made the call, which model was requested, which route served it, how many tokens

This post contains Railway referral links. If you sign up through one I get a bit of credit. I build Old Light , a real-time strategy game that runs in the browser. Claim stars, grow an economy, send fleets, all while other players and NPC empires do the same. The second a build finishes or a fleet lands, the server pushes it to every connected client over a WebSocket. That last part, a long-lived server holding an open socket, rules out most of the usual hosts. Here's what it ruled in. Why not Vercel or Netlify Serverless shines when your backend is stateless functions. It's the wrong shape the moment you need a socket that stays open: socket.io wants one process that lives for the whole session, and serverless boots per request and then freezes. You can bolt on a managed WebSocket service, but that's a second system to run and pay for. Railway runs your service as a normal long-lived process, so socket.io just connects. Fly.io does this too with more knobs to turn. I wanted to ship, so Railway won. Monorepo, two services Old Light is an npm workspaces monorepo: a shared types package, an Express plus TypeORM plus socket.io API, and a Vite web app served by a small Express server. On Railway that's two services on the same repo, each with its own root directory and build command, shared built first. They deploy as separate origins, so the web app reads the API's URL from VITE_API_URL . Vite bakes that in at build time, so it's a build variable, not a runtime one. Postgres is a plugin that injects DATABASE_URL , and production runs migrations rather than synchronize . WebSockets need nothing special until you run more than one instance, at which point you'd add a Redis socket.io adapter. I haven't left a single box yet. A healthcheck that stops version skew Two services don't go live at the same instant. Push a commit that touches both, the web finishes first, and for a minute your new frontend is calling API routes that don't exist yet. It 404s, then heals itself o

AI founders love the glamorous agent stories: coding agents, sales agents, AI doctors, AI lawyers. But if you dig through the YC 2026 batch data, one of the more interesting signals is decidedly unglamorous: insurance . Out of 477 real-ish company records in the current snapshot, 25 match insurance-related keywords — about 5.2% — and 8 companies sit in the Fintech → Insurance subindustry. Not a tidal wave. But it's enough to suggest something worth paying attention to: insurance is quietly becoming one of the better wedges for AI agents that actually ship. The reason is simple. Insurance is wall-to-wall documents, rules, judgment calls, exceptions, approvals, claims, underwriting, and cross-system coordination. In other words: wall-to-wall work that agents can do and humans hate doing. Insurance is not fintech's leftover category Most people file insurance under "slow fintech": aging distribution, legacy systems, long processes, heavy regulation. From an AI builder's perspective, that list of flaws reads more like a list of opportunities. Insurance workflows are highly structured — but not fully structured. Policies, claims files, medical records, photos, repair estimates, payout history, compliance clauses: the inputs are messy and heterogeneous. Yet every step has a crisp objective: is this covered, what documents are missing, how should this risk be priced, can this pass approval. That's not a chatbot problem. It's an agent problem — reading documents, following procedures, calling systems, leaving audit trails, handling exceptions. And precisely because it's complex, insurance is more likely to command real budget than yet another AI writing tool. Agents die without boundaries; insurance comes with them built in The most common failure mode for early agent products: they sound like they can do everything and end up doing nothing well. Insurance workflows hand you boundaries for free: Inventory and asset processes can be automated end to end Medical prior authori

If you could pick only one counterintuitive number from the YC 2026 batches, make it this one: out of 477 real-ish company records, 366 list San Francisco as their location — roughly 77%. For comparison: New York City has 24. London 10. Boston 7. Los Angeles 4. Fully remote? 3 companies. Even if you add the 11 tagged "San Francisco + Remote", the conclusion doesn't budge: AI startups aren't spreading across the map. They're re-concentrating in one city. This isn't Bay Area nostalgia. It's industry structure casting a vote. Remote won work. It didn't win startup density. One of the most popular takes of the past few years: software teams can start anywhere, so companies no longer need the Bay Area. That take wasn't entirely wrong — tooling, cloud services, open models, and online fundraising genuinely lowered the barrier to starting a company. But the YC 2026 location data is a reminder that a lower barrier is not the same as a vanished advantage. Building an AI startup isn't just writing code. It runs on model gossip, talent flow, customer pilots, investor feedback, peer pressure, and extremely fast narrative iteration. Much of that works online. But the densest informal information still travels fastest offline. San Francisco's edge was never the office space — it's collision frequency. AI made same-city learning matter again In the classic SaaS era, most domain knowledge came from customers and product cycles were relatively stable. You could build a vertical software company in any city and grind toward PMF at your own pace. The AI era doesn't work like that. Model capabilities turn over every few months. Agent architectures keep getting rewritten. Inference costs, context windows, voice, tool calling, and eval infrastructure are all on rolling release. A seemingly minor technical shift can redraw your product's boundaries overnight. In that environment, whoever hears real feedback earlier, learns earlier what others tripped over, and understands earlier what inv

For a long time, education and work rewarded one thing above all else: the ability to produce correct answers. School exams were built around it. Technical interviews were built around it. Even many engineering jobs were built around it. The person who could respond faster, explain better, and deliver the right output was often seen as the most valuable person in the room. But AI is changing that. Today, answers are becoming cheap. With modern AI tools, anyone can generate code, summaries, documentation, architecture drafts, and even product ideas in seconds. The scarcity is no longer in producing answers. The scarcity is in defining the right problem. That is why, in the AI era, learning how to ask better questions matters more than learning how to write better answers. The Bottleneck Has Moved The biggest shift is not that AI can answer questions. The bigger shift is that answering is no longer the hardest part. When answers can be generated instantly, the real bottleneck becomes: What exactly should be asked? What is the real problem behind the surface request? What constraints actually matter? What outcome is considered good enough? AI can generate many possible answers. But it still depends heavily on the quality of the question. A vague prompt creates vague output. A precise question creates leverage. In that sense, the person who defines the problem is now more important than the person who simply responds to it. The Problem Setter Is More Valuable Than the Problem Solver This idea may sound exaggerated at first, but it becomes obvious in practice. Suppose someone says: Optimize this system. That sounds like a reasonable task, but it is actually too weak to produce a strong result. Optimize for what? Cost? Latency? Reliability? Simplicity? Team productivity? Now compare it with this: We have a Node.js API running on AWS ECS. Under burst traffic, CPU throttling causes latency spikes. How can we reduce p95 latency without increasing infrastructure cost by more

We just opened the waitlist for Something, and the part that surprised me most while building it wasn't the multi-agent orchestration — it was how hard it is to make an AI actually disagree. Every model we tested defaults to being helpful, which in practice means agreeable. Even when explicitly prompted to "find flaws," the outputs would soften into "here are some considerations" instead of a real critique. We had to engineer around this specifically: Separate system prompts with opposing reward framing — one agent optimizes for identifying growth potential, the other is explicitly told its only success metric is surfacing a disqualifying flaw Structured output forcing a verdict, not a summary — the skeptic agent (Nothing) has to commit to a specific weakness category (unit economics, timing, technical feasibility) rather than hedging across all of them A reconciliation step where both outputs get merged into one conviction score, so the founder isn't just reading two contradictory paragraphs If anyone's built adversarial agent setups and hit the same "it just wants to agree with me" problem, curious how you solved it. [Everyone who has a brain is a founder here] something-waitlist.vercel.app

There's a project on every developer's machine that has Sass installed for one reason: &:hover {} . Not @mixin . Not @each . Just the nesting. The variables long since became --custom-properties . The only thing still justifying node_modules/sass is the ability to write child selectors inside parent rules. CSS added that natively in 2023. It shipped in Chrome 112, Firefox 117, and Safari 16.5 — every major browser released in the last two years. The compiler is not earning its spot anymore. What you've been writing in Sass The classic pattern — component styles scoped to a block, with states and modifiers nested inside: .card { padding : 1 .5rem ; border-radius : 0 .5rem ; background : var ( -- surface ); & :hover { background : var ( -- surface-hover ); } & __title { font-size : 1 .125rem ; font-weight : 600 ; } & --featured { border : 2px solid var ( -- accent ); } } The output is flat, specificity-controlled CSS. The source is organized by component. That's the trade Sass nesting has always offered — and native CSS now offers the same deal. The same thing in native CSS .card { padding : 1.5rem ; border-radius : 0.5rem ; background : var ( --surface ); &:hover { background : var ( --surface-hover ); } & .card__title { font-size : 1.125rem ; font-weight : 600 ; } & .card--featured { border : 2px solid var ( --accent ); } } Two differences are worth noticing. First: pseudo-classes work exactly as in Sass — &:hover resolves to .card:hover with no extra syntax. Second: descendant selectors require an explicit & followed by a space. & .card__title becomes .card .card__title . This is where native nesting differs from BEM's __ / -- convention: in native CSS, & is a selector reference , not a string concatenation operator. If you're using BEM naming heavily, &__foo becomes & .block__foo . The compiled output is identical; the source is slightly more explicit about what's happening. Media queries nested inside their rules This is the feature that earns native nesting a pe

I believe Angular upgrades have become much smoother these days. Most of the time, a simple ng update is enough to move to the latest version. Instead, I spent hours chasing errors that looked completely unrelated to the real problem 😭 After upgrading the project to Angular 21, I started seeing errors like these: Cannot find module '@angular/material/chips' Cannot find module '@angular/material/dialog' Then another one appeared: Error: The current version of "@angular/build" supports Angular ^19... but detected Angular version 21.x instead. At first, it looked like Angular Material wasn't installed correctly but i think the actual issue was a version mismatch inside the project. Some packages had already been upgraded to Angular 21: @angular/core @angular/common @angular/material But the build system was still using: @angular-devkit/build-angular@19 Since Angular's build tools are tightly coupled with the framework version, the compiler started producing misleading errors. The build pipeline was the problem. The Commands That Helped I used these commands: npm ls @angular-devkit/build-angular npm explain @angular-devkit/build-angular They showed that my project was still resolving Angular 19's build package. That was the clue I needed and than I verified that every Angular package was using the same major version. Then I cleaned the project completely: rm -rf node_modules rm package-lock.json npm cache clean --force npm install It takes time usually.(and I did it several times cause Im failed 😃) Finally, I confirmed that all Angular packages were aligned before building again.

Turn your phone into a Google Slides remote Discussion | Link

Dictate, rewrite, translate, and an agent in a single device Discussion | Link

Sparrow is Raku automation framework comes with useful plugins people can use to automate infrastructure. Scc plugin allows to check Linux essential configuration files for security compliance. Here some examples: Sysctl $ sudo sysctl -a | s6 --plg-run scc@check = sysctl 12:24:07 :: [task] - run plg scc@check=sysctl 12:24:07 :: [task] - run [scc], thing: scc@check=sysctl [task run: task.bash - scc] [task stdout] 12:24:08 :: abi.cp15_barrier = 1 12:24:08 :: abi.setend = 1 12:24:08 :: abi.swp = 0 12:24:08 :: abi.tagged_addr_disabled = 0 12:24:08 :: debug.exception-trace = 0 12:24:08 :: dev.cdrom.autoclose = 1 12:24:08 :: dev.cdrom.autoeject = 0 12:24:08 :: dev.cdrom.check_media = 0 12:24:08 :: dev.cdrom.debug = 0 12:24:08 :: dev.cdrom.info = CD-ROM information, Id: cdrom.c 3.20 2003/12/17 12:24:08 :: dev.cdrom.info = 12:24:08 :: dev.cdrom.info = drive name: 12:24:08 :: dev.cdrom.info = drive speed: 12:24:08 :: dev.cdrom.info = drive # of slots: 12:24:08 :: dev.cdrom.info = Can close tray: 12:24:08 :: dev.cdrom.info = Can open tray: 12:24:08 :: dev.cdrom.info = Can lock tray: 12:24:08 :: dev.cdrom.info = Can change speed: 12:24:08 :: dev.cdrom.info = Can select disk: 12:24:08 :: dev.cdrom.info = Can read multisession: 12:24:08 :: dev.cdrom.info = Can read MCN: 12:24:08 :: dev.cdrom.info = Reports media changed: 12:24:08 :: dev.cdrom.info = Can play audio: 12:24:08 :: dev.cdrom.info = Can write CD-R: 12:24:08 :: dev.cdrom.info = Can write CD-RW: 12:24:08 :: dev.cdrom.info = Can read DVD: 12:24:08 :: dev.cdrom.info = Can write DVD-R: 12:24:08 :: dev.cdrom.info = Can write DVD-RAM: 12:24:08 :: dev.cdrom.info = Can read MRW: 12:24:08 :: dev.cdrom.info = Can write MRW: 12:24:08 :: dev.cdrom.info = Can write RAM: 12:24:08 :: dev.cdrom.info = 12:24:08 :: dev.cdrom.info = 12:24:08 :: dev.cdrom.lock = 0 12:24:08 :: dev.raid.speed_limit_max = 200000 12:24:08 :: dev.raid.speed_limit_min = 1000 12:24:08 :: dev.scsi.logging_level = 68 12:24:08 :: dev.tty.ldisc_autoload = 1 12:24:08

A government report claims DOGE didn’t access sensitive systems. It also says the agency deleted records that would show if they had.

Stretch seasonal produce, preserve leftovers, and build a pantry that lasts with our favorite food dehydrators for every budget.

tags: hardware, iot, opensource, electronics As software developers, many of us reach a point where writing code inside a virtual environment isn't quite enough—we want to manipulate the physical world. Whether it's blinking an LED via an ESP32, visualizing audio frequencies on a desk display, or building custom bench tools, hardware hacking is easily one of the most rewarding rabbit holes to fall down. At NextPCB , we’ve spent the past few years supporting the open-source hardware community by sponsoring independent creators, makers, and embedded engineers to help turn their digital schematics into real, physical circuit boards. If you’re looking for inspiration for your next weekend project, here are four curated roundups of real-world projects featuring open-source files, schematics, and design breakdowns. 1. Retro Tech & Nostalgic Geek Culture Builds 🎮 There’s something uniquely satisfying about recreating classic tech using modern hardware components. From custom hand-held arcade consoles to retro synth modules and glowing mechanical displays, retro builds combine aesthetic nostalgia with serious embedded engineering. These projects aren't just for show—they showcase clever power management, compact multi-layer PCB routing, and custom display interfaces. 👉 Check out the project breakdowns & schematics: 8 Retro Geek Culture PCB Projects: Open-Source Gerbers & Schematics 2. Smart Audio & Interactive Visual Displays 🎵 Audio reactive electronics bridge the gap between digital signal processing (DSP) and hardware UI/UX. Think custom spectrum analyzers, RGB LED matrix drivers, and tactile smart knobs that update in real-time. Building custom audio hardware requires paying extra attention to noise isolation, clean power delivery, and signal integrity—making these projects fantastic learning material for intermediate hardware devs. 👉 Explore the audio & display designs: Smart Audio & Interactive Display PCBs: Open-Source Design Guide 3. DIY Power & Precision Lab Equipm

Welcome to our weekly digest, where we unpack the latest in account and chain abstraction and the broader infrastructure shaping Ethereum. This week: Robinhood takes its own chain and agentic trading live; WalletConnect and MetaMask make the case that account abstraction is what will keep AI agent payments safe; a new essay argues Ethereum should fund its founding period like a young nation-state; and Vitalik shares the updated Lean Ethereum roadmap that makes privacy and quantum resistance first-class. Robinhood Chain Goes Live With Agentic Trading WalletConnect and MetaMask on Agentic Payments The Case for Founding-Period Ethereum Funding Vitalik Shares the Updated Lean Ethereum Roadmap Please fasten your belts! Robinhood Chain Goes Live With Agentic Trading Robinhood has launched the public mainnet of Robinhood Chain , its biggest move yet into onchain finance. Built on Arbitrum, the Layer 2 is designed for tokenized real-world assets and DeFi, and it went live at a London keynote with day-one partners including Uniswap. With the mainnet, Robinhood’s Stock Tokens are now fully live in more than 120 countries, though availability varies by jurisdiction. Users can trade tokenized equities around the clock and put them to work across DeFi, including in lending pools and as trading collateral. The company also rolled out Robinhood Earn , a decentralized lending product that pays an estimated 7% on its dollar-backed USDG stablecoin through a self-custody wallet, powered by the Morpho protocol. Perpetual futures and maker fees as low as 0% round out the trading updates. The most relevant piece for our readers is Agentic Accounts for crypto. Through a Trading MCP, eligible users can connect their AI model of choice to Robinhood’s data and tools, while keeping control by setting how much capital to allocate and which safety guardrails apply. This is account abstraction territory in all but name. Letting an agent trade from a self-custody wallet within human-defined limit