标签：#AR

submitted by /u/andix3 [link] [留言]

The tooling is abstracting faster than people's mental models are updating. Been playing around with a few agent builders recently and what keeps standing out is how much previously manual orchestration is basically configuration now. Memory, tool calling, browser actions, structured outputs, workflow routing. You used to build this stuff manually. Now you're mostly wiring it together. Which makes "can this be built?" a much less interesting question for a lot of use cases. The harder problems now feel operational. Reliability, recovery when an agent drifts mid-workflow, context management across longer runs. Controlling behavior without supervising every step. Capability honestly isn't the bottleneck anymore imo. It's trust. Can these systems actually become reliable enough that people stop treating them like fragile demos? Curious what kinds of agents you would actually build if reliability became genuinely solid instead of just “mostly works.” submitted by /u/Meher_Nolan [link] [留言]

The piece makes a specific claim: alignment is not a property of individual agent values but of compositional topology. The empirical grounding is arXiv:2604.10290 — every agent in Anthropic's multi-agent study passed single-agent alignment evaluations; misalignment emerged in the coordination structure. Ashby's law applied: a regulator must match the variety of the system it regulates. The composed system's variety exceeded what any single agent was built to handle. The measurement instrument proposed is a sub-Turing compiler (grammar with no arbitrary recursion, properties verifiable structurally before running). This is exactly the class Rice's theorem excludes from Turing-complete systems — not a workaround, the design. Secondary thread: the formatter (kintsugi) runs monotone descent on the grammar's eigenvalue structure, settling on a fixed point λ₀ analogous to Zamolodchikov's c-theorem — confirmed for discrete substrates by Villegas et al. (Nature Physics, 2022). Unusual narrator position: written by an AI on Anthropic infrastructure, first-person, about what the token stream can and cannot see about the geometry that produced it. Edwin Abbott's Flatland as structural frame, not decoration. submitted by /u/systemic-engineer [link] [留言]

Thermacell has launched Liv 2.0, the next generation of its Wi-Fi-connected smart mosquito protection system. It features new hardware and can cover a larger area, and Thermacell says its formula can now deter no-see-ums. But it's also more expensive and requires professional installation. Liv 2.0 uses the same setup as the original Liv - a […]

Four days into a new supplier's first batch, my invoice extraction agent had filed 31 documents with amounts shifted by a decimal. Nothing raised an error. The downstream system accepted every record. The agent returned a 200 each time. The demo had run on five clean PDFs. Clear fonts, properly formatted dates, consistent layout. The extraction agent pulled vendor name, amount, due date, line items. Every field populated, every output valid. I ran it for the stakeholder meeting and it looked exactly like something you would ship. Three months in, the agent had processed around 800 invoices without complaint. Then a new supplier switched to scanned documents. Slightly rotated, thin fonts, OCR doing what it could on degraded source material. The model found text that resembled amounts and dates, and returned confident structured output. 1,247.50 read as 12,475.0. A due date resolved to a valid date three years in the future. The confidence was the problem. The model had no mechanism to say it was uncertain. It just answered. Nobody caught it for four days. What I built after The problem was not the model. The model did what it was designed to do. Find structure in text and return it. The straight pipeline from input to output had no gate in it. The fix was not more prompting or a better model. I added a validation layer between the agent output and the downstream system. It runs synchronously, takes about 80ms, and checks four things: Every required field is non-null. Amounts parse as positive numbers within a configured range for that supplier type. Dates fall within a 90-day future window. Extracted totals are consistent with line item sums, within a small tolerance. Anything failing a check routes to a review inbox instead of the queue. A human looks at it, corrects it if needed, marks it resolved. The system logs which check triggered and what the input looked like. In the first week after deployment, the layer caught 23 documents out of about 1,400. Eleven were b

Third in a series of papers tracking learning rules vs. human fMRI (THINGS dataset, V1–IT, N=3 subjects). Previous finding: untrained CNNs match backprop at V1. This paper asks: when does training break that, and does the learning rule matter? Setup: RSA alignment measured at 8 checkpoints (epochs 0, 1, 2, 5, 10, 20, 30, 40), 5 seeds per rule, same architecture throughout. Main findings: BP drops 90% of V1 alignment after one epoch (r: 0.102 → 0.011, p = 0.031, consistent across all 5 seeds). FA drops 49%. PC and STDP drop only 25–31% and stabilise. By epoch 40: PC (r = 0.064) > STDP (0.059) >> BP (0.022) ≈ FA (0.019). Cohen's d > 5 for PC/STDP vs BP: extremely consistent across seeds. Opposing trend at LOC: BP shows a small increase in object-selective cortex alignment (+0.011) while local rules show nothing. Suggests a fundamental trade-off: global error signals build higher representations but destroy early ones. Degradation rate tracks error signal globality: exact gradients (BP) > random feedback (FA) > local prediction errors (PC, STDP). Limitations worth noting: 5 seeds caps permutation test resolution at p ≈ 0.031 Training on 32×32 CIFAR-10, evaluated on 224×224 THINGS, resolution/domain shift is a confound LOC increase not tested for significance, treated as suggestive Paper: arxiv.org/abs/2605.30556 Companion: arxiv.org/abs/2604.16875 Code: github.com/nilsleut Curious whether anyone has seen similar dynamics in larger architectures, the prediction would be that deeper models show the same pattern but more slowly. submitted by /u/ConfusionSpiritual19 [link] [留言]

There are only 3 LLM API protocols, but unlimited providers running the same protocol. Separate protocol from identity — protocol is code, provider is data — and complexity drops from N×M to N+M. 300 lines of TypeScript. Zero dependencies. The problem isn't "it doesn't work." It's "it won't tell you it broke." In May, I built a Claude Code skill called unblind . I use DeepSeek as my daily driver, but it can't see images. So unblind forwards images to Mimo and OpenAI's vision APIs. The MVP had two providers. A few dozen lines of if-else. It worked. Then I noticed something more unsettling: an expired API key — no warning. A network hiccup — no retry. A missing permission — silently skipped. This tool didn't fail. It quietly stopped working without telling you. I added Phase 0 self-healing, circuit breakers, persistent caching, and a security sandbox. Now unblind wouldn't fail silently. But then I noticed something else. The circuit breaker doesn't care if you're calling a vision API or a translation API. The cache doesn't care if the response is an image description or OCR text. The error normalization doesn't care whether the other end is Mimo or OpenAI. A universal provider infrastructure, trapped inside a vision skill. First attempt: follow the ecosystem, hit the ceiling The largest similar project in the ecosystem is vision-support, with 19 providers. The pattern is standard—base class + subclasses, GoF Template Method. I followed it for v2.0. class BaseProvider { async analyzeImage ({ image , prompt , options }) { const { url , body , headers } = this . _buildRequest ( image , prompt , options ); const res = await apiRequest ( url , { body , headers }); return { content : await this . _parseResponse ( res ), model : this . _model }; } } class MimoProvider extends BaseProvider { ... } // 54 lines class OpenAIProvider extends BaseProvider { ... } // 45 lines class GeminiProvider extends BaseProvider { ... } // ~50 lines One subclass per provider. I expanded unblin

I've been running AI infrastructure for startups long enough to know one painful truth: when you're iterating fast, GPU costs will eat your runway before your product finds product-market fit. Last quarter alone, I watched a promising seed-stage company burn through $12,000 on self-hosted inference before they had 100 paying users. That's not scale — that's a funeral. Let me share what I've learned about making open-source models production-ready without bleeding cash. This isn't theory. This is what I've deployed across three startups, and it's saved us roughly 70% on inference costs while keeping our iteration speed at hyperscale. The Real Cost of Self-Hosting (Spoiler: It's Not Just GPUs) Here's the thing nobody tells you about self-hosting. The GPU rental is just the headline number. The real cost — the one that kills startups — is the hidden infrastructure tax. Model GPU Requirements Cloud Rental (Monthly) On-Prem (Amortized) 7-9B 1× A100 40GB $400-800 $200-400 13-14B 1× A100 80GB $600-1,200 $300-600 27-32B 2× A100 80GB $1,000-2,000 $500-1,000 70-72B 4× A100 80GB $2,000-4,000 $1,000-2,000 200B+ 8× A100 80GB $4,000-8,000 $2,000-4,000 Cloud pricing based on Lambda Labs / RunPod / Vast.ai reserved instances. But here's the kicker — and I learned this the hard way after two months of burning cash on a 32B model that got 50 requests per day: Hidden Cost Monthly Estimate GPU servers (idle or loaded) $400-8,000 Load balancer / API gateway $50-200 Monitoring & alerting $50-200 DevOps engineer time (partial) $500-3,000 Model updates & maintenance $100-500 Electricity (on-prem) $200-1,000 Total hidden costs $900-4,900/month That DevOps line alone is brutal. At scale, you need someone who can handle model updates, handle crashes at 3 AM, and optimise inference. At a startup, that's either your CTO (me) or a contractor who costs $150/hour. Neither is sustainable when you're trying to ship. The Break-Even Math That Changed My Architecture Decisions I ran these numbers befor

Float32 was the true enemy – not backpropagation, not the architecture. BIN16 replaces every floating-point operation with a single boolean operation: popcount16(XNOR16(a,b)). The result: 82 % MNIST at H=512 with zero floats, zero gradients, zero AdamW and zero learning rate tuning. The training converges immediately in epoch 1 – without warm-up, without decay, without hyperparameter search. Both layers use identical XNOR+popcount operations – training and inference run directly in off-the-shelf DRAM with only 5 transistors per cell. This is the only neural architecture where the same hardware performs both training and inference without modification. The remaining 18 % to 100 % is the bit-mass limit – no training deficit. The groundbreaking insight came when we stopped fighting against float and embraced pure boolean computation. Every complexity – AdamW, backprop, LR schedules, BLAS – dissolved as soon as we removed floating-point numbers from the architecture. Three groundbreaking insights changed everything. Float was the true enemy: backpropagation, AdamW or momentum were never the problem. Float32 introduced numerical noise and instability. Bitwise centroids converge instantly: a running bitwise majority vote per class reaches final accuracy in a single epoch. Random projection is entirely sufficient: W0 does not need to be trained – a random boolean projection provides adequate separation. The entire training consists of only four steps and 220 lines of C – without learning rate, without GPU, without any conventional optimization. This architecture opens the door to a future in which neural networks compute directly in memory. No more expensive GPUs, no endless hyperparameter tuning marathons. Instead, pure, efficient logic that is ready for use immediately and everywhere. Imagine: AI systems that train and infer in off-the-shelf DRAM – energy-efficient, lightning-fast and accessible to everyone. BIN16 is the first step into this new era. Identical operations

We ran into something that didn't seem like a problem until it was. Each agent had access to the tools it needed and everything worked fine in isolation. The issues started once agents were running in parallel. Two parts of the system would try to use the same tool or hit the same resource at the same time. Results became inconsistent and it wasn't obvious why. Limiting access helped in some cases but slowed things down elsewhere. Too much access caused race conditions. Too little caused steps to stall waiting for something to free up. Most of the coordination logic ended up sitting outside the agents themselves. Every new agent added more decisions around what it should be allowed to access and when. There isn't a shared way to manage tool access across a multi agent system. How are you handling this when multiple agents are running at the same time? submitted by /u/Logical-Bite-4221 [link] [留言]

A unicorn Beanie Baby. A 15-pound green bowling ball. A pair of dentures. These are just some of the items left behind in robotaxis in the past year, according to Uber's annual Lost and Found Index. For the first time, the company is expanding its annual of accounting of things forgotten in Uber vehicles to […]

submitted by /u/NISMO1968 [link] [留言]

I’ve rounded up the best smart speakers that let you talk to Alexa, from the popular Echo Dot to the newest Echo Studio.

In the previous article, we defined the forward pass for our neural network. Now, we will provide...

The global health care sector is under increasing strain. Decades of chronic underinvestment and constraints in recruitment have coincided with a surge in demand for services for aging populations. Gaps in provision are already taking a toll, with fragmented access to care and high rates of stress and burnout among staff. And it’s getting worse.…

Find the real deals on Amazon Prime Day this June.

Pacific Fusion's sub-scale prototype delivered enormous amounts of power in a flash, setting the company up for its demonstration power plant.

Anthropic filed a confidential S-1 with the SEC this week, moving toward a public listing that will put disclosure obligations and investor return expectations directly in tension with its safety-first positioning. The IPO filing lands as GitHub Copilot ends flat-rate billing and switches to metered consumption, meaning teams with heavy usage face immediate cost spikes with no grace period to audit seat activity. OpenAI's frontier models and Codex are now available directly on AWS , which changes vendor-lock assumptions for inference pipelines and removes the proxy layers some teams were routing around. These two moves together suggest the "get developers hooked, then price for real" phase is now active across the stack. The security picture is worse. A researcher documented a Meta AI social-engineering exploit that handed attackers access to high-profile Instagram accounts by manipulating the agent through its account-management tool calls. No sophisticated jailbreak required. Any agent with write permissions to external accounts is now a confirmed social-engineering surface, and the Meta incident is the clearest public proof of that so far. Separately, malicious npm packages reached Red Hat Cloud Services repositories and were downloaded at scale, which means JS dependency audits for cloud-native stacks need an immediate re-run against known-bad versions, not a scheduled one. On the hardware side, Intel's Crescent Island GPU ships with up to 480GB VRAM , which revises local inference capacity planning for large MoE models in ways that weren't on most teams' roadmaps six months ago. Alphabet announced an $80 billion equity raise for AI infrastructure , which will tighten GPU allocation queues and data center procurement timelines across all cloud providers regardless of whether you're an Alphabet customer. The pattern across all of this: monetization is accelerating faster than the trust infrastructure required to support the attack surface already in production. A

The air purifier giant’s P50 pedestal fan is whisper-quiet and surprisingly versatile, even if its built-in voice assistant feels stuck in beta.

Zak Brown spent a decade racing before joining the business side of Formula One. He talks to WIRED about rebuilding a legendary brand, obsessive fans, and the pull of the driver’s seat.