标签：#AR

Honestly, when I saw Cloudflare's announcement, my first reaction wasn't "oh cool, something new"—it was "there goes another giant company proving the thing I've been saying all along." What Cloudflare Actually Did On August 4, Cloudflare (yes, the infrastructure giant that blocks traffic and runs CDNs for half the internet) launched "Cloudflare Wallets" and something called cloudflare.pay. It gives AI agents three things they didn't have before: An identity —a recognizable wallet handle so others know exactly which agent is paying A wallet —funded with stablecoins, so the agent can actually pay A spending cap —and this one is enforced by Cloudflare's infrastructure itself The structure here is what I think matters most. You (the human) hold an Account Wallet where the funds live; then, through an API key, you grant a limited slice of spending power to individual Virtual Wallets that your agents actually use. Here's the analogy that makes it click: the Account Wallet is your company's master account, and each Virtual Wallet is a prepaid card with a spending limit that you hand to one of your AI employees. The only difference is these "employees" are AI, and the limit on the card isn't managed by a credit card company's risk engine—it's written directly into Cloudflare's infrastructure. Payments run through the now widely-discussed x402 protocol: an agent wants to buy a service, and it pays for that one transaction on the spot with stablecoins. I should be upfront about something: it's not fully usable yet. As of August 5, it's in a "launched, you can reserve your cloudflare.pay name" state. The real funding, Virtual Wallets, and programmatic spend controls are, per Cloudflare, coming "over the next few months." So this is a clear directional statement, not a mature product you can fully adopt today. Why I'm Not Reading This as "One New Product"—I'm Reading It as an Industry Consensus If this were just Cloudflare doing its own thing, I wouldn't bother writing about i

When someone asks whether to use Azure OpenAI Service or the direct OpenAI API, the starting point is this: the models running on both platforms are identical. GPT-4o, GPT-5, and the o-series models you deploy on Azure have the same weights, the same capabilities, and the same output quality as the ones you call from platform.openai.com, and what changes between the two platforms is the infrastructure where they run, the authentication mechanism, and the compliance guarantees the provider can offer on those requests. What changed in 2026 Azure AI Foundry was renamed Microsoft Foundry on January 1, 2026, and Azure OpenAI Service now lives inside that unified platform alongside the model catalog, development tooling, and agents. References to Microsoft Foundry in new documentation point to what used to be Azure AI Foundry. In July 2026, the GPT-5.6 family arrived with Sol, Terra, and Luna available on Azure the same day as on the direct OpenAI API. Historically Azure lagged four to eight weeks behind new model releases because Microsoft validates them within their compliance frameworks before making them available, and while that gap still exists for some specific features and APIs, for the main models in the GPT-5 family availability is converging. Where data is processed When you call GPT-4o from the OpenAI API, the request goes to OpenAI's own infrastructure, which is centralized and gives you no control over which region processes your data. For most use cases that doesn't matter, but for organizations with data residency requirements, regulatory compliance needs, or industries like healthcare, banking, or government, that detail can determine whether the service is usable at all. Azure OpenAI runs the same models within the boundary of your Azure tenant, so the data you send in prompts doesn't leave to OpenAI's infrastructure but processes in the Azure regions you choose. That's what makes it possible to meet HIPAA, SOC 2, EU data residency, and other certificati

The False Dichotomy The agent ecosystem is split into two camps: Camp Loops (Boris Cherny, OpenAI Agents SDK, LangGraph): > "Agents are loops. Plan → act → observe → repeat. The loop is the atomic unit." Camp Graphs (Steve Yegge, Gas Town, LangGraph DAGs, CrewAI): > "Agents are graphs. Nodes are agents/tools. Edges are handoffs. The graph is the architecture." Both are right. Both are incomplete. What Loops Get Right Loops capture temporal behavior — the iterative, self-correcting nature of agent work: - Replanning on failure (AdaPlanner, ReAct) - Budget enforcement (token caps, step limits, cost ceilings) - Verification gates (process reward models, extraction floors) - Learning loops (feedback → lessons → advisory → suppress) A loop is a control structure. It says: keep going until condition X. What Graphs Get Right Graphs capture structural composition — how capabilities connect: - Handoffs (peer-to-peer control transfer) - Parallel execution (swarms, polecats, fan-out/fan-in) - Supervision trees (Erlang/OTP-style restart strategies) - Provenance (who called whom, with what context) A graph is a dependency structure. It says: A feeds B, B feeds C, C can restart A. The Missing Layer: A Compiler Between Repos and Runtime Here's what neither camp addresses: Where do the nodes come from? Today: - You find a repo on GitHub - You hope it implements what it claims - You wire it into your graph/loop - You pray it works There's no verification layer. No SBOM. No attestation. No provenance. HURCULES: The Compiler Between Repos and Runtime HURCULES sits between the repository and the agent runtime: GitHub Repository → HURCULES → Verified Capability Package → Agent Runtime (Loop or Graph) It doesn't care if your runtime is a loop or a graph. It produces verified capabilities that work in either. What HURCULES Compiles | Input | Output | |-------------------------------|---------------------------------------------------| | Raw repo (any language) | Deterministic map (file tr

Agents don't search like humans. They issue hundreds of queries per session, need structured extraction over snippet relevance, and care more about p95 latency than the perfect top result. Keenable built a search API around those constraints with a 100B+ page proprietary index, SQL-like query interface, and continuous benchmarking against agent-like workloads. The founders (Amazon AGI web grounding, Yandex search lead) are betting that wrapping existing search APIs won't cut it when agents become the primary consumers of web data. The architecture reveals what changes when you optimize for machine callers instead of human eyeballs. Why Agent Search Needs Different Plumbing Human search optimizes for the first three results and tolerates 500ms variance. Agent search runs in tight loops where every query blocks downstream tool calls. The contract shifts: Query volume : Agents issue 10-100x more queries per task than humans per session Latency budget : p95 matters because agents serialize tool calls; tail latency compounds across multi-step workflows Result consumption : Agents parse structured data, not blue links; relevance scoring for human click-through doesn't align with extraction success Query patterns : Agents use precise filters (date ranges, domain constraints, schema hints) that humans rarely specify Traditional search APIs built for human traffic handle agent workloads poorly. Rate limits assume sporadic queries. Pricing tiers penalize high-volume programmatic access. Relevance models optimize for engagement metrics that don't exist in agent contexts. The 100B-Page Index Decision Keenable maintains its own crawl and index instead of wrapping Google, Bing, or Brave. This is expensive but unlocks control over: Crawl strategy : Agents need fresh data on niche domains that human-centric crawlers deprioritize. A proprietary crawl can target high-churn sources (job boards, pricing pages, event listings) and re-crawl on agent-driven schedules rather than PageRank-

Foundation models are expensive. A trading agent that calls GPT-4 for every price prediction burns budget fast. Lightweight forecasters are cheap to run but expensive to train, especially when you only have a handful of examples. MetaCaster introduces a meta-harness architecture where agents don't forecast directly. Instead, they train specialized lightweight models on-demand from few-shot examples and textual context. This is not another AutoML wrapper. The meta-agent orchestrates data generation, architecture selection, and training loops to produce task-specific forecasters in minutes. The result is a deployable model that runs inference without touching the foundation layer again. The Economic Gap Time-series forecasting in production faces a resource trap: Foundation models (TimeGPT, Chronos) deliver strong zero-shot performance but cost $0.002 to $0.02 per prediction at scale. Lightweight forecasters (PatchTST, DLinear, FEDformer) run for pennies but need thousands of training samples and hours of GPU time. Few-shot scenarios (new trading pairs, emerging markets, privacy-sensitive health data) don't have enough history to train from scratch. MetaCaster targets the intersection: resource-constrained environments where you need specialized models but can't afford foundation API calls or long training cycles. Meta-Harness Architecture The system has three layers: 1. Meta-Agent Orchestrator The top-level agent receives a few-shot time series (as few as 5-10 examples) and optional textual context (domain descriptions, seasonality hints). It decides: Which lightweight forecaster architecture to instantiate (PatchTST, DLinear, Autoformer, etc.) What synthetic data generation strategy to apply How to configure the training harness (learning rate, epochs, augmentation) The meta-agent uses a learned policy, not heuristics. It's pre-trained on a meta-dataset of diverse forecasting tasks so it generalizes to new domains. 2. Data Generation Agents These agents expand the f

Garmin just took the wraps off its new line of rugged Fenix 9 smartwatches, with the base model featuring an OLED display with a brightness of up to 3,000 nits, making it twice as bright as its predecessor. Starting at $999.99 for the 43mm case option, the Fenix 9 has 50 percent more RAM and […]

I hope this is okay to share since it is not self promotion and it is open source. Some of my friends were let go as part of an "AI Transformation". So they got together and created Open Executive as a tool to replace the CEO and other executives. Hopefully, turnabout is fair play and might even get some folks to think twice about using AI to replace people. It is free and available here: https://github.com/SenteLabsAI/OpenExecutive submitted by /u/Fearless-Might-5439 [link] [留言]

About energy use and other topics. He has lots of supporting links. https://youtu.be/Kf4ivd0THb0 https://youtu.be/ny_3PRz6Zeg submitted by /u/silver_chief2 [link] [留言]

With school and sports starting again, these discounts on Instant Pots, cookware, and coffee gear arrive right on time.

Truck driver here, zero coding background. I Built an AI news aggregator over a few evenings because I was sick of seeing the same story five times. It pulls from about a dozen AI news sources, auto-summarises each article so you get the gist without clicking through and dedupes stories covered by multiple outlets into one card instead of five separate headlines saying the same thing. I deliberately went for a no-nonsense Win98-ish look — no clutter, no bells and whistles, just the feed. Built with Next.js/Supabase, synced every two hours via GitHub Actions. No coding experience going in, mostly just kept iterating with Claude Code until it worked. Not selling anything, just proud it works and thought a few people here might actually use it. Feedback welcome :) submitted by /u/MODisclosure [link] [留言]

It's my article, it is about how to circumvent any even theoretical optimal AI watermark based on statistical biases via pseudorandom generators like Google's SynthID. Let me know what you guys think. Generally, I do not think watermarking is the right solution, hence I am sharing my idea how to circumvent it. How many thesises are out there that are basically slop but made with human effort. Now text length is not a valid measure anymore, you actually have to do some real research. I think that is awesome. submitted by /u/JulianHabekost [link] [留言]

OpenAI has introduced an Admin plugin for ChatGPT Work and Codex. It lets workspace admins review activity and credit usage, manage members and groups, check permissions, and adjust usage limits from a conversation. The plugin stays inside each admin's existing role and permissions. OpenAI says it shows what was requested, whether it completed, and what changed. It can also route some requests for approval in Slack or Microsoft Teams. The practical part is the control layer. An admin tool that can change workspace settings needs clear permissions, approval steps, and a result people can audit. Source: https://openai.com/index/introducing-admin-plugin/ Supporting report: https://www.tradingview.com/news/reuters.com,2026:newsml_L8N44M1HY:0-openai-says-introducing-the-admin-plugin-for-chatgpt-work-and-codex/ submitted by /u/Codeblix_Ltd [link] [留言]

I've supposed their approach based on their website, they are of course more complex. I set up a local "Agent Arena" ( qwen2.5-coder:14b on an RTX A4500) to test 5 AI agent frameworks on an ultra-strict coding task. Classic multi-agent "swarms" either hallucinated success, burned 500k+ tokens in pointless debates, or rubber-stamped completely off-topic code. Only frameworks relying on mechanical grounding (actual compilers/linters) rather than an "LLM critic" produced viable results. The Challenge: The "Triple Constraint" I asked each framework to build an Authentication & Rate Limiting middleware in Rust that had to satisfy three contradictory constraints: Absolute Security: Cryptographic hashing ( sha2 ) and timing-attack protection ( subtle::constant_time ). Performance: Under 1ms latency under a 10k request load. Strict Quality: 100% unit test coverage, and 0 clippy warnings. The Golden Rule: Exact same local model for everyone ( qwen2.5-coder:14b ), isolated environments (sandboxes), same scaffolding. No cheating via paid external APIs. Autopsy of the Results (How they failed) 1. AutoGen: The Token Sink (Blind debate) The Approach: A GroupChat (Coder ↔ SecurityCritic ↔ PerfCritic). What happened: The agents debated in circles for 6 rounds, burning through 517,000 tokens . They eventually reached a "consensus"... on an off-topic script measuring latency instead of handling authentication. The critic agent rubber-stamped a completely flaky test. 2. CrewAI: The Rubber Stamper The Approach: Hierarchical chain (Architect → QA → Reviewer). What happened: The code is mechanically green (tests and clippy pass), but the logic drifted entirely. It coded a WebSocket handshake, completely ignoring cryptographic hashing and constant-time execution. The QA "Reviewer" saw the code compile and green-lit the whole thing without checking the original specs. 3. MetaGPT: Process Hallucination The Approach: "Software Company" cascade (SOP). What happened: It generated an almost emp

Understanding unique photochemistry of such materials will help in conservation, storage, and exhibition.

El chatbot va último: cómo ordeno las cinco automatizaciones que más me piden Tengo 16 flujos en producción para pymes y la lista de pedidos se repite casi siempre igual. Lo que no se repite es cuál conviene hacer primero. La discusión habitual las ordena por dificultad de construcción, y esa es la métrica equivocada. Construir es la parte barata: el modelo escribe la mayor parte. Lo que se paga después es el mantenimiento, y ahí el orden se da vuelta. Van las cinco, ordenadas por lo que cuesta sostenerlas, de la peor a la mejor. 5. Responder consultas frecuentes La que todos piden primero y la que más mantenimiento tiene. Parece contenida: son las mismas veinte preguntas. No lo es, porque el contexto que necesita se mueve todo el tiempo. Cambia el catálogo, cambian los precios, cambia el horario en verano. Meta cambia requisitos de la API. El modelo se actualiza y el mismo prompt deja de comportarse igual. Y sobre todo: es la única de las cinco donde el error lo ve el cliente . Un bot que inventa un precio no genera un ticket interno, genera un reclamo. Si igual va primera —y a veces va, porque es la que se ve—, presupuestala con el abono adentro desde el día uno. 4. Turnos y reservas La más engañosa de la lista. Tomar un turno es trivial; el problema es todo lo demás. Cancelaciones, reprogramaciones, dos personas pidiendo el mismo horario con cuatro segundos de diferencia, el turno que se cargó a mano en el sistema y el bot no vio. Es estado compartido con escritura concurrente , que es un problema viejo y conocido, disfrazado de chatbot. Si la agenda vive en un sistema con API decente, baja bastante. Si vive en un Google Calendar que además tocan tres personas a mano, no la subestimes. 3. Mover datos entre sistemas La que más valor devuelve y la que menos depende de vos. El trabajo real casi nunca es la transformación de los datos: es el sistema del otro lado. Y en pymes ese sistema suele ser uno de gestión local, sin API pública, sin documentación, y con un prov

Dreame, the Chinese vacuum company that aspires to be a global technology giant, is reportedly shutting down its automotive project after funding from the government dried up. According to CarNewsChina, the company's automotive division called "Project Starry Sky" once employed over 1,000 people, but now only a handful legal and HR staffers remain, charged with […]

A polished update to Google’s foldable brings real improvements, but the price bump and rampant competition make it a tough sell.

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is free and source-available on Github. Star git-lrc to help devs discover the project. Do give it a try and share your feedback. I knew XOR. Truth tables, bit flips, the whole deal, nothing new there. Then I was reading some article about P2P networking and ran into the phrase "XOR distance" and just kind of stopped. XOR I know. Distance I know. XOR distance ? That's not a thing, that's two things wearing a trenchcoat. So I went and actually learned how it works, and it turns out it's one of those ideas that's simple once it clicks and mildly infuriating right up until it does. So let's do this properly. We're going to talk about bits, buckets, and why your node's "neighbors" have nothing to do with where they physically live. The one-line version XOR distance between two IDs is just: XOR their bits together, read the result as a number. That number is your "distance." Bigger number, farther apart. Smaller number, closer. That's it. That's the tweet. Obviously that's not satisfying, so let's actually build it up. Step 1: what XOR even does XOR (exclusive or) looks at two bits and asks one question: "do you two agree?" A B A XOR B 0 0 0 0 1 1 1 0 1 1 1 0 Same bits, you get 0. Different bits, you get 1. XOR is basically the "spot the difference" operator of computer science. Now take two IDs (in real systems these are 160-bit or 256-bit hashes, but let's use 4 bits so nobody has to squint): A = 1100 B = 1010 ---- 0110 (this is the XOR) Read 0110 as a plain binary number and you get 6. So distance(A, B) = 6. Congrats, you just computed an XOR distance by hand, you can put that on your resume now. Step 2: why we're even allowed to call this a "distance" Math is picky about the word "distance." For something to count as a proper metric, it needs three properties, and XOR happens to nail all three, which honestly feels like a happy accident but isn't. distance(A, A) = 0. An

Hi everyone, I’m researching how to design an AI agent for a medicine-reminder system. The agent has to decide, at each relevant time, whether to: send a reminder, wait (do nothing for now), or notify another person (e.g. caregiver), when it does not have complete information about the patient (has the dose already been taken? is the person nearby/attentive? are there adherence barriers? etc.). I’m trying to frame this properly before diving into implementation. Right now I’m looking at it as a sequential decision problem under partial observability (POMDP / belief-state RL territory), but I’m not sure how far that framing is actually useful in practice for this kind of system. I’d really appreciate any pointers on: Is a POMDP / belief-state approach overkill here, or is it the right formalization? What simpler alternatives (contextual bandits, MDP with engineered features, rule-based + uncertainty thresholds, etc.) have people used successfully for similar “remind vs wait vs escalate” decisions? Papers, open-source projects, or real systems that tackle medication adherence / context-aware reminders with uncertainty or incomplete observations. Common practical pitfalls (reward design, observation noise, alert fatigue, safety/escalation logic, evaluation metrics) that aren’t obvious from the theory. Any recommended starting points for someone new who wants to move from “I understand the concepts” to a small working prototype or simulation. I’m mainly in research/preparation mode right now, so even high-level advice, key papers, or “here’s what I’d do differently” comments would be very helpful. Thanks! submitted by /u/Senior_Disaster_7307 [link] [留言]

It's currently only appearing on Pixels running Android 17.