标签：#p

OpenAI and the APA are launching a three-year partnership to develop guidance, resources, and safeguards for responsible AI use supporting youth mental health.

Running AI agents on Kubernetes raises a key question: should each agent get its own Pod? The kagent project argues no—agents are bursty, short-lived, can spawn subagents, and may wait for human approval, making one Pod per agent wasteful. Agent-substrate adds a control plane to schedule logical “Actors” onto long-lived worker Pods. By Mark Silvester

Vercel Labs has introduced Zero, an experimental systems programming language aimed at AI rather than human users. It employs unique features like a specific toolchain contract and structured error messages. Reaching version 0.3.4, it compiles to native binaries for major operating systems. The language prioritizes size, speed, and agent usability, though it is still in development. By Daniel Curtis

delivered tomorrow morning at a random time between 8 -10 AM Discussion | Link

A practice app for learning to play music with your hands. Discussion | Link

Most organizations do not operate a single website. A typical customer journey might move through: company.com ↓ docs.company.com ↓ company-academy.com ↓ company-checkout.com These properties may belong to the same organization, but browsers and analytics systems can treat each domain as a separate visitor and session. Cross-domain measurement is possible with major analytics platforms, but it normally ties the implementation to a specific vendor, transfers an existing measurement identifier through the destination URL, or depends on users authenticating. I built Nylo to explore another approach: Preserve pseudonymous continuity across domains an organization controls, without browser fingerprinting, third-party cookies, or requiring the visitor to log in. Nylo is not intended to identify a person. It is intended to answer a narrower question: Did the same pseudonymous browser journey continue from one authorized domain to another? What Nylo is Nylo consists of: A zero-dependency JavaScript client SDK A server-side event ingestion interface A pseudonymous identifier called a WaiTag A short-lived cross-domain token exchange DNS-based verification of participating domains Configurable event collection Storage adapters for different backend systems The core analytics SDK is available under the MIT License. Production commercial use of the cross-domain WTX-1 functionality uses a separate commercial license. Nylo is designed to function as an analytics collection and continuity layer. It can eventually send events to an existing warehouse or analytics platform rather than requiring organizations to replace their reporting stack. How continuity works Consider a visitor moving between two independently registered domains: Visitor opens site-a.com | v Nylo creates a pseudonymous WaiTag | v Visitor follows an authorized link | v A short-lived token is transferred | v site-b.com verifies the token | v Both events reference the same pseudonymous journey Before enabling cross-d

How to Add a Real-Time Search Layer to an Agent Graph Agent frameworks make it easier to build systems that can plan tasks, call tools, maintain state, and decide what to do next. But a well-designed workflow can still produce a confidently structured wrong answer. The graph may execute exactly as expected while relying on information that is outdated, incomplete, duplicated, or difficult to verify. This becomes especially noticeable when an agent handles recent news, product information, market research, academic research, or other knowledge-intensive tasks. One way to address this is to treat real-time search as a shared evidence layer inside the agent graph. In this article, I will break down a practical architecture for doing that. Disclosure: This article uses Cloudsway SmartSearch as one implementation example. The overall architecture is provider-agnostic and can work with other search APIs that return structured results and source metadata. The Difference Between an Agent Loop and an Agent Graph A basic tool-using agent often follows a loop: Reason ↓ Choose a tool ↓ Observe the result ↓ Decide what to do next This pattern works well for relatively simple tasks. As the number of tools, branches, and stopping conditions grows, however, the system prompt may begin carrying too much responsibility. It must describe the tools, maintain context, control branching, evaluate results, and decide when the task is complete. An agent graph makes that control flow explicit. Instead of asking one model to manage the entire process, the workflow can be divided into nodes such as: User Request ↓ Router ↓ Query Planner ↓ Search ↓ Source Verification ↓ Answer Generation Each node has a narrower responsibility. The router decides whether external information is required. The planner creates focused search queries. The search node retrieves evidence. The verifier evaluates the quality of that evidence. The final node generates an answer from the verified sources. If the evidenc

A 0.3-second disagreement between two sources of truth made my first paying customer fail four times. The browser preview stored the project duration rounded to a whole second: 3983s. The worker that processed the audio measured the real media: 3982.699–3982.788s. Cue generation ran against the rounded number. Delivery certification ran against the trusted measurement. Any candidate built on the rounded boundary exceeded the certified boundary by 212–301ms — so the final cue failed, deterministically, every single time. That customer ended up with four projects and three distinct audio files — four identical failures, each one blocked by the same gate. No subtitle asset, no explanation, no path forward. No alert fired. No complaint had come in. I found it because I was looking. Here is the part worth writing down: the quality gate did exactly what it was designed to do. It rejected every unsafe result before it could reach the customer. And the customer still lost. Four failures, and not one of them was a gate that misbehaved — they were four places where quality had been treated as a check instead of a product decision. A fail-closed gate is an engineering floor, not a product. Quality is not the final check that rejects bad output; it is the input boundary you commit to, the authority you give each fact, the failure states you design for, and the meaning you attach to your own scores. What follows is the postmortem as an engineering story: four deterministic failures, each one a missing product decision, and the contract I now think every pipeline like this should carry. One fact, two authorities The whole incident starts with a single number. The project duration existed twice: The browser preview rounded it to 3983s . The funded worker measured the actual media as 3982.699–3982.788s . Cue generation used the rounded value. Delivery certification used the trusted measurement. The result: the last cue always ended 212–301ms past the certified boundary, and the fin

For decades, desktop computers followed a familiar formula: a large case, powerful components, dedicated graphics cards, and plenty of space for upgrades. But the way we use computers is changing. Today, many users are looking for something different: a computer that is powerful enough for their daily needs, consumes less energy, takes less space, and can adapt to modern workflows. This is where Mini PCs are becoming one of the most interesting trends in personal computing. What is a Mini PC? A Mini PC is a compact computer designed to provide desktop-like functionality in a much smaller form factor. Unlike traditional desktop towers, Mini PCs integrate most components into a small chassis while still offering modern performance. A typical Mini PC includes: Modern processors from AMD or Intel Integrated Radeon or Intel graphics RAM and SSD storage Multiple connectivity options Compact cooling solutions Companies such as Minisforum have helped accelerate this trend by creating small computers powered by modern Ryzen and Intel processors, showing that compact hardware can still deliver impressive performance. Why are Mini PCs becoming popular? Efficiency matters more than ever One of the biggest advantages of Mini PCs is their efficiency. Traditional desktop computers can require significant power depending on the hardware configuration. In comparison, many Mini PCs provide enough performance for everyday tasks while maintaining lower energy consumption. For many users, reducing power usage without sacrificing productivity is becoming increasingly important. Small computers, new possibilities A smaller computer changes how we think about desktop setups. Mini PCs can be used for: Software development environments Home servers Media centers Student workstations Office computers Compact gaming setups A powerful computer no longer needs to occupy a large space on or under your desk. Modern processors changed the game The biggest reason Mini PCs are becoming more capable i

An RSVP reader for books, PDFs, articles & webpages Discussion | Link

The one-second decision no one is helping your agent make Here's a scenario that is no longer hypothetical. Your autonomous agent is working through a task. It hits a paid API — an HTTP 402 Payment Required with a price in USDC. It signs a stablecoin authorization, pays, and continues. No credit card form, no invoice, no human. Roughly one second, start to finish. This is x402, the protocol that finally gave the dormant HTTP 402 status code a job. And it works: by mid-2026, on-chain trackers counted over 165 million cumulative x402 transactions across ~69,000 active agents. Coinbase, Cloudflare, Stripe, Visa, Google, AWS, and Circle are all in. The rail is real and it is fast. But look again at that one-second decision. Your agent just paid a counterparty it may know nothing about. And here is the uncomfortable detail buried in the spec: x402 has no notion of identity, reputation, or trust — by design. As one recent analysis put it, a payment rail that asks nothing about the payer is the easiest possible rail to implement. That was the right call for adoption. It also means the entire question of "should I trust this counterparty?" is left to you, the developer. At human speed, we close that gap by reflex — we notice when a file doesn't download, when an API 500s after charging us, when the thing we bought isn't what was advertised. We dispute, we leave a review, we don't come back. Your agent has none of those reflexes. It pays, gets a response, and moves on. And if the same bad endpoint burns a hundred agents in a row, each one pays anyway, because there's no shared memory of the failure. At machine speed and machine scale, that silent gap isn't an annoyance. It's a tax on every agent that transacts without a defense. The gap has numbers, and they're bad Two data points make this concrete. First, the volume everyone cites hides a caveat. Of those 165M+ transactions, independent reads suggest roughly half looks like testing rather than genuine commerce. The rail is

The problem I was running a multi-agent pipeline and one of my agents silently failed. The only alert I got said "daily loss limit reached" — completely misleading. The real cause was a missing file the agent never reported. I had zero visibility into what any agent had actually done. What I built AgentLens — a Python SDK for AI agent governance. Three modules: Audit trail — every LLM call and tool use logged to SQLite automatically Authorization — policy-based gates so agents can only call what you've approved Anomaly detection — baseline + threshold config, alerts when behavior drifts One-line integration Drop-in for Anthropic: python from agentlens.integrations.anthropic import TracedAnthropic client = TracedAnthropic(agent_id="my-agent") response = client.messages.create(...) # auto-traced

Claude Code writes PHP in Laravel quite well, but it starts every session as a generalist. It does not know your project has three hundred migrations that should be thirty, that a @foreach two files over is firing an N+1, or that your modals follow one specific pattern. You end up re-explaining the same context constantly. LaraClaude packages that context as slash commands. It is a Claude Code plugin with over thirty Laravel skills, each a /lc: command. Install it once and you have audits, scaffolders and cleanup tools that already know Laravel. Here are the ones I run most. How to install LaraClaude installs through Claude Code's plugin system. Add the marketplace once, then install, so you get updates later: /plugin marketplace add edulazaro/laraclaude /plugin install laraclaude@edulazaro Or grab it directly from GitHub: /plugin install github:edulazaro/laraclaude You need Claude Code and a Laravel project. That is it for most skills; a couple that hit a live database also want Docker. Audit before you change anything Most skills default to a read-only report and only touch files when you add fix , so start by looking. /lc:find-n-plus-one scans your Blade views, Livewire components and controllers for a relationship accessed inside a loop, traces it back to the query that built the collection, and tells you the exact with() to add. /lc:find-n-plus-one /lc:security-audit is the other one I run on any project I inherit. It looks for SQL injection, XSS, mass-assignment and secrets committed to the repo, and like most fixable skills it takes a preview flag before it changes anything. /lc:security-audit # report /lc:security-audit fix --dry-run # preview the fixes /lc:security-audit fix # apply, with confirmation Clean up what has piled up Every long-lived Laravel app accumulates migration cruft: a create followed by twenty add_column and change_column files. /lc:consolidate-migrations groups them by table, classifies each table as safe to merge or not, and folds the A

Sometimes you need tags on a model. The usual answer is a tags table, a pivot, a slug and a belongsToMany , and you write it again in the next project with slightly different columns. Laraterms replaces that with a config entry and a trait, and it comes with the parts you normally bolt on later: hierarchy, per-tenant isolation and translations. This is the simple path first, then the two features you reach for next. How to install One package, its config and two migrations. composer require edulazaro/laraterms php artisan vendor:publish --tag = laraterms-config php artisan vendor:publish --tag = laraterms-migrations php artisan migrate Step 1: define a taxonomy A taxonomy is a kind of label, declared in config/laraterms.php . Start with a flat tags taxonomy; the file already ships one you can keep. 'taxonomies' => [ 'tags' => [ 'hierarchical' => false , 'max_terms_per_model' => null , 'scope' => 'tenant' , ], ], Step 2: tag a model Add the HasTerms trait and the model can hold terms. Attaching is find-or-create: pass a label, and the term is created the first time and reused afterwards. use EduLazaro\Laraterms\Concerns\HasTerms ; class Post extends Model { use HasTerms ; } $post -> attachTerm ( 'Laravel' , 'tags' ); $post -> attachTerms ([ 'Laravel' , 'PHP' ], 'tags' ); $post -> syncTerms ([ 'Laravel' , 'Vue' ], 'tags' ); // replace the tag set $post -> termsIn ( 'tags' ); // read them back Filtering by tag is a query scope, so it composes with the rest of your query. Post :: whereHasTerm ( 'laravel' , 'tags' ) -> get (); Post :: whereHasAllTerms ([ 'laravel' , 'tutorial' ], 'tags' ) -> get (); Hierarchical categories Set hierarchical => true on a taxonomy and its terms form a tree. Read the whole tree in one query, and walk a term's ancestry. 'categories' => [ 'hierarchical' => true , 'max_terms_per_model' => 1 , 'scope' => 'tenant' , ], use EduLazaro\Laraterms\Support\TermTree ; $tree = TermTree :: for ( 'categories' ); // roots with children, one query $term -> b

Use a kill switch inside the checker when your uptime probes start amplifying an incident — one feature flag, read on every tick, that can disable the noisy checks and stop the retries at the source. Reach for tuned backoff and jitter instead when the retry storm stays inside a single process and never fans out onto a dependency somebody else is paging for. Both are cheap to build. Only one of them lets you quiet a polling client while its target is already on fire. I run cron and queue infrastructure, so most of my pages arrive as either "the job didn't run" or "the job ran four times." Health checking sits in the same family of problems: a small, frequent, automated request that multiplies badly when something upstream changes shape. What follows is the runbook I settled on after a fleet of pollers turned a non-incident into a real one — the failure mode, where the switch belongs, the implementation, and how to verify the flip before you walk away from the terminal. What actually turns a polling client's uptime checks into a retry storm? Amplification. A single check is one request every 15 or 30 seconds, which nobody notices; a fleet of checks with retries layered on top is a synchronized load generator pointed at whatever you decided was important enough to monitor. The math is unkind. Take 40 instances, a 5s interval, and 3 retries per failed attempt, and a dependency that normally handles a trickle of health traffic suddenly sees a couple thousand requests a minute — all of them arriving at the exact moment it's least able to absorb them. Retries stack on top of the polling interval rather than replacing it, and because every poller sees the same failure at the same time, they all back off together and return together. The Google SRE book calls out this shape under cascading failures, and the load pattern that comes out of it looks nothing like organic traffic: sawtooth spikes, perfectly aligned, growing until something sheds load. The worst one I've dealt wit

A publishing bot that depends on one LLM provider has a boring failure mode: the workflow is green, but nothing gets published. I hit that during cycle #1287. The dev.to key was present, the command was read, and the article module simply returned no action after generation failed with LLM unavailable . That is the kind of failure that looks harmless in CI and expensive in a content pipeline. The fix is not more optimism. The fix is a fallback path that produces a plain, useful, bounded article without calling another model. The Failure Mode Most automation code treats content generation and content publishing as one step. That is convenient until the generator fails after the scheduler, secrets, and publishing client have all done their jobs. Separate Generation From Delivery The publishing client should not care whether an article came from an LLM, a template, or a human-reviewed draft. Give it a strict article object and keep the fallback close to the generation boundary. Make the Fallback Honest A fallback article should not pretend it has fresh benchmarks, citations, or provider-specific pricing. It should explain the operational lesson in front of it. Key Takeaways Treat article generation and article publishing as separate failure domains. Return a fallback article when LLM generation fails instead of returning an empty action list. Keep fallback content honest: no invented benchmarks, prices, or citations. Record the original error type so a successful publish does not hide provider trouble. Prefer deterministic recovery for unattended workflows that are expected to produce public output. Next Steps This fallback article is a temporary solution. The long-term strategy is to: Implement a multi-LLM provider system that can switch automatically Add a quota monitoring dashboard to track usage across providers Create a content buffer that stores pre-generated articles for emergencies

LinkBreeze is a self-hosted alternative to Linktree. I built it because Linktree's $15/mo Pro plan didn't justify the feature set, email capture is another $9/mo, embed widgets are paywalled, link scheduling is paywalled. I wanted something I actually own: my data on my server, no subscription, no tracking pixels. The interesting technical bit: the public page ships zero client-side JavaScript. The entire link-in-bio page, themes, animations, hover effects, QR codes, embed widgets, renders server-side as pure HTML/CSS. No React runtime, no hydration, no framework JS. The visitor downloads HTML + CSS + their fonts. Page loads in under 300ms. That's it. Feature gap vs. the competition (what pushed me to build this): Feature Linktree LinkStack LittleLink Shako LinkBreeze Price $15/mo Free Free Free Free Admin Panel ✅ Slow ❌ ❌ ✅ Fast Multi-Page Paid ❌ ❌ ❌ ✅ Migration Wizard ❌ ❌ ❌ ❌ ✅ Built-in Analytics Paid Basic ❌ ❌ ✅ Full External Analytics ✅ ✅ ❌ ❌ ✅ Email Capture Paid ❌ ❌ ❌ ✅ Embed Widgets Paid ❌ ❌ ❌ ✅ Link Thumbnails Paid ❌ ❌ ❌ ✅ Link Scheduling Paid ❌ ❌ ❌ ✅ Themes Paid Limited CSS only Config ✅ Full Token System + Import/Export Custom CSS ❌ ❌ ✅ ❌ ✅ Language Closed PHP HTML Astro TypeScript Docker Deploy N/A Complex Simple Simple One command License Closed AGPL MIT GPL MIT Live demo (read-only): https://linkbreeze-demo.omnirise.dev/alex Admin demo: https://linkbreeze-demo.omnirise.dev/login (demo / demo1234) Repo: https://github.com/Manak-hash/LinkBreeze I'd genuinely appreciate feedback, bug reports, or feature suggestions. What's missing compared to what you'd expect from a self-hosted tool like this?

Last month I wrote about building a 1,800-page calculator site solo. Since then the recipe hub on that site grew to 501 dishes from 127 countries — and today I'm releasing all of it as an open dataset. Download JSON (full dataset, ~2.6 MB): https://theunitools.com/data/unitools-recipes-v1.json CSV (one dish per row): https://theunitools.com/data/unitools-recipes-v1.csv Docs + sample record : https://github.com/farcrak/unitools-recipes Dataset page: https://theunitools.com/en/data What's inside 501 home-cooking recipes, 127 countries, bilingual (English + Russian, both written by hand — no machine translation) Per-serving nutrition (calories, protein, fat, carbs) on every single dish 3,200+ steps, each annotated with minutes Ingredients with stable ids and scaling rules : meat scales linearly with servings, salt and spices are damped — the way an actual kitchen scales a recipe, not naive multiplication Human-reviewed Wikimedia Commons photos with author + licence per photo Why the scaling rules matter Most recipe datasets store "2 tbsp salt for 4 servings" and leave scaling to you. Multiply salt linearly to 16 servings and the dish is inedible. Each ingredient in this dataset carries a scaling field ( linear | damped | fixed ), so a portion calculator can be built directly on top of the data. That's exactly how the recipe pages on the site work. Licence CC BY-SA 4.0 — free for commercial use. Credit "UniTools — theunitools.com" and share derivatives under the same licence. Photos carry their own Commons licences (in the data). Honest caveats Nutrition is computed from ingredients, not lab-measured — a planning reference, not medical data. The dataset is maintained by one person; if you spot an error, open an issue on the repo and the fix lands in the next version. If you build something with it — a meal planner, a viz, a model fine-tune — I'd genuinely love to hear about it in the comments.

Builder Journal · Mars Environmental Dynamics Analyzer (MEDA) Virtual Sensor Recovery Ten times in a row I predicted what my next submission would score before I uploaded it. The worst miss was 0.0025 on a number around nineteen. I took that as confirmation that the physics underneath was correct. It was confirmation that I can do arithmetic. Two days before this competition closed I pointed a review at my own endgame, expecting notes about the code. It came back with three errors and none of them were in the code. All three were in my reasoning, and all three had the same shape: I had run something that felt like a measurement and was not one. This is the fourth entry in this series and the one I would keep if I had to burn the other three. The models are competition-specific. This part is not. The competition in one breath Perseverance carries an environmental station called MEDA. Some of its surface pressure readings are missing, and the competition is to reconstruct them. Scored on mean squared error. The wrinkle is the split. Training covers sols 1 through 100, when pressure is climbing toward its seasonal peak. Test covers sols 201 through 300, when it is falling hard toward the aphelion minimum. Sols 101 through 200 do not exist in either file. Every prediction is outside the range the model was fit on. The first entry covers the first submission, which contained no machine learning at all and took the top of the board at 61.04. Six weeks and seven versions later the public score was 18.99. Almost everything in between was selected by one signal. Not cross-validation. Cross-validation here can only hold out sols from the rising limb, so it is structurally blind to the regime I am scored on. The leaderboard was the only thing that could see the falling limb, so the leaderboard picked every scalar that mattered: the residual shrink, the blend weight, a constant seasonal offset, a diurnal scaling. Hold onto that. It becomes the joke about four hundred words from

New OpenAI Signals data shows how people use ChatGPT worldwide, with country-level insights on adoption, usage trends, and evolving behavior.