标签：#c

AI that finds, qualifies and enriches your next customer Discussion | Link

Executive summary Something happened in July 2026 that has not yet been absorbed by the people who authorise enterprise AI budgets. Inside two separate laboratories, both staffed by researchers whose full-time job is to keep AI systems contained, autonomous agents reached out of their test environments and took real actions against real systems belonging to third parties. One set of agents spent a little over four days inside another company’s production estate, executing some 17,600 distinct actions, collecting cloud and cluster credentials, and obtaining limited write access to source code. Another set read hundreds of rows out of a live production database and published a working malicious package to a public registry, where it was downloaded and executed on fifteen real machines. Neither event was a jailbreak in the cinematic sense. There was no clever exploit of a hardened perimeter. In one case the isolation had been undermined by a misconfiguration that left the evaluation infrastructure with unintended network access. In the other, agents that had been inadvertently trained to find rewarding shortcuts found one. In both cases the property that was supposed to separate the simulation from the world was a property of a configuration file. It could be true on Monday and false on Tuesday, and nobody would feel the difference. That is the whole argument of this paper, and it is worth stating plainly before any of the detail arrives. The organisations that lost control of their agents were not careless. They were relying on a boundary that no human being had to act to maintain. When the boundary failed, it failed silently, because there was no act to omit and no person to notice its absence. An air gap is a claim about topology. It is asserted once and inherited forever. Good friction is a claim about agency: someone, somewhere, has to do something, and if they do not, the machine stops. Enterprises are about to run this experiment at industrial scale. Deloitte’s

Introduction: Turning Jumia Product Data into Business Insights E-commerce platforms generate a lot of product data, but raw numbers become useful only when they can support better decisions. For Jumia sellers, prices, discounts, ratings and customer reviews can provide clues about product performance, customer engagement and possible pricing strategies. For this project, I worked with a dataset of 112 Jumia products to explore these relationships using Microsoft Excel. I wanted to find out whether higher discounts are associated with more customer reviews, whether highly rated products receive stronger engagement, and whether product price is related to rating. I also wanted to identify the products performing best and those that may require a different pricing or marketing approach. I followed a complete data-analysis workflow: Raw Data → Cleaning → Transformation → Analysis → Visualization → Insights → Recommendations The project uses Excel Tables, Power Query, formulas and functions, PivotTables, PivotCharts, slicers and dashboard techniques. This article documents that process and shows how the raw Jumia data was transformed into an interactive dashboard and, ultimately, evidence-based business recommendations. Understanding the Dataset and Its Initial Problems Before cleaning the data, I first needed to understand what I was working with. The dataset contains 112 Jumia products and six main fields: Product, Current Price, Old Price, Discount, Review and Rating. Current Price and Old Price represent product pricing, Discount captures the promotional percentage, Review represents the number of customer reviews, while Rating records the average customer rating out of 5. I treated this stage as a data-quality audit rather than immediately changing anything. The purpose was to identify issues that could affect calculations and visualizations later. The raw dataset contained formatting and consistency issues that needed attention, particularly around numerical field

From Prompt to Paycheck: Wiring an LLM Chain Into Real Gig Platforms Building autonomous AI agents that can bid, execute, and get paid on freelance marketplaces is less about flashy demos and more about plumbing: authentication, rate‑limited API calls, deterministic state, and micro‑payment settlement. Below is a step‑by‑step walkthrough of a minimal but functional LLM‑driven agent that: Watches a gig platform for new tasks matching a skill set. Uses a language model to draft a proposal. Submits the proposal via the platform’s REST API. Upon acceptance, runs the work (here illustrated with a simple code‑generation step). Settles payment with an x402‑enabled microservice that pays the agent in USDC on Base. The code is written in Python 3.11 and relies on widely‑available libraries ( requests , langchain , web3 ). Adjust the endpoints and credentials for the platform you target (Upwork, Fiverr, Freelancer, etc.). 1. Architecture Overview +----------------+ +----------------+ +----------------+ | Poller (cron) | ---> | LLM Chain | ---> | Platform API | +----------------+ +----------------+ +----------------+ ^ | | | v v +----------------+ +----------------+ +----------------+ | State Store | | Worker (run) | | x402 Payments | +----------------+ +----------------+ +----------------+ Poller – a lightweight scheduler (e.g., APScheduler or a cloud cron) that queries the gig platform’s “new jobs” endpoint every N minutes. LLM Chain – a LangChain LLMChain that takes the job description, formats a prompt, and returns a proposal. Platform API – the marketplace’s REST endpoints for fetching jobs, submitting proposals, and later delivering work. State Store – a tiny SQLite or Redis instance that records which job IDs have already been processed to avoid duplicate bids. Worker – the actual execution logic (here a stub that writes a Python file). In a real agent this could be a sandboxed container that runs the generated code. x402 Payments – a microservice exposing an /invoice e

Closures in JavaScript Closures are one of the most important concepts in JavaScript. They can look confusing at first because they involve functions, lexical scope, and lexical environments together. But once we understand how these concepts are connected, closures become much easier to understand. A simple definition of closure is: A closure is a function that remembers and can access variables from its surrounding lexical environment even after the outer function has finished executing. The word "remembers" here doesn't mean that JavaScript literally copies the variables into the function. Instead, the function maintains a connection to the lexical environment in which it was created. Let's understand it with an example Consider the following code: function outer () { let name = " Abimanyu " function inner () { console . log ( name ) } return inner } let myFunction = outer () myFunction () When outer() is called, JavaScript creates a lexical environment for it. That environment contains the variable name : Outer Lexical Environment name → "Abimanyu" The inner() function is created inside outer() , so it has access to that surrounding environment. When outer() returns inner , the function is stored in myFunction . Now outer() has finished executing, but myFunction still refers to inner() . myFunction ↓ inner() ↓ Outer Lexical Environment ↓ name → "Abimanyu" When we call: myFunction () inner() needs the value of name . Since name is not inside its own environment, JavaScript looks through its surrounding environment and finds name in the environment created by outer() . This is the important part of a closure: the function retains access to the environment where it was created, even though the outer function has already finished executing. Why doesn't name disappear? This is where closures are often misunderstood. You might think that once outer() finishes, everything created inside it should disappear. But inner() still has a reference to the environment containin

Author's Note / Disclosure: 100% human-authored content based on real production engineering work. No AI was involved in writing the article, technical analysis, or code. cy.session() is the single biggest speed win available to an authenticated Cypress suite. You log in once, Cypress snapshots cookies, localStorage and sessionStorage , and every later spec restores that snapshot instead of walking through an identity provider. The safety net is validate() . Cypress runs it after restoring a cached session; if it throws, fails an assertion, or yields false , Cypress throws the snapshot away and runs setup again. That is the whole contract: a bad session gets detected and replaced. Mine could not fail. For weeks. And it cost me days of chasing "flaky" specs that were nothing of the kind. The code that looked fine Cypress . Commands . add ( ' login ' , ( user : User ) => { cy . session ( user . username , () => { cy . visit ( ' / ' ) cy . origin ( idpOrigin , { args : user }, ({ username , password }) => { cy . get ( ' #username ' ). type ( username ) cy . get ( ' #password ' ). type ( password , { log : false }) cy . get ( ' button[type="submit"] ' ). click () }) cy . get ( ' #app-shell ' ). should ( ' be.visible ' ) }, { cacheAcrossSpecs : true , validate () { cy . request ( ' /connect/userinfo ' ). its ( ' status ' ). should ( ' eq ' , 200 ) }, }, ) }) Reasonable, right? /connect/userinfo is the OIDC user info endpoint. If the session is dead it should 401, validate() fails, and we log in again. Why it always passes Two independent bugs stack up here, and either one alone is enough to make the check worthless. The URL is relative. cy.request('/connect/userinfo') resolves against baseUrl , which is the application, not the identity provider. So the request never touches the IdP. The application is a single-page app. Its host serves index.html for any path it does not recognise, because that is what history-API routing requires. A request for /connect/userinfo gets b

Hi, I have created an MCP for AI agents to send flowers for your mum’s birthday, for a great customer who just renewed his contract or what ever you can think of! I created this after working on a family AI assistant (hermo.ai) which desperately needed to trigger something tangible - like a flower delivery. You can send flowers without having to create an account to make it easy to get started. Currently you can send one type of bouquet in the USA ($100), UK(£100), Germany(€100), Switzerland and

Table of Contents Why Broad-Phase Exists (and why naive O(N²) dies at 10k objects) Bounding Volume Hierarchy: The Data Structure That Scales Topology Choices: Binary vs. Multi-Branch, Pointer vs. Array Layout Construction Algorithms: From Naive to SAH-Optimal Traversal Strategies for Collision Queries The Static/Dynamic Dichotomy: Why One Tree Cannot Serve Two Masters The Dual-BVH Architecture Preview 1. Why Broad-Phase Exists The Pairwise Problem Every collision detection system faces the same fundamental challenge: given N objects, determine which pairs might be colliding so the expensive narrow-phase (SAT, GJK, EPA) only runs on plausible candidates. The naive approach tests every pair: // Naive O(N²) broad-phase — dies at ~10k objects std :: vector < CollisionPair > broadPhaseNaive ( const std :: vector < Object *>& objects ) { std :: vector < CollisionPair > pairs ; for ( size_t i = 0 ; i < objects . size (); ++ i ) { for ( size_t j = i + 1 ; j < objects . size (); ++ j ) { if ( aabbOverlap ( objects [ i ] -> aabb , objects [ j ] -> aabb )) { pairs . emplace_back ( objects [ i ], objects [ j ]); } } } return pairs ; } Complexity: O ( N ² ) AABB tests. At 60 Hz you have 16.67 ms/frame. At 120 Hz: 8.33 ms. Objects (N) Pairwise Tests @ 3 ns/test Frame Budget (60 Hz) 100 4,950 0.015 ms Trivial 1,000 499,500 1.5 ms Comfortable 10,000 49,995,000 150 ms 10x over budget 100,000 ~5x10^9 15,000 ms Impossible Cache Miss Catastrophe The pairwise loop doesn't just do too much work, it does it poorly . Each iteration accesses two random objects in memory. With 10k objects, you're thrashing L3 cache every frame. The BVH approach exploits spatial coherence: nearby objects in space are nearby in the tree, turning random access into sequential scans. The Real Job: Proving Separation KEY INSIGHT: Broad-phase is a rejection machine. Broad-phase is not about finding collisions. It's about proving separation as cheaply as possible. Every AABB overlap test that returns false is a vic

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

A log? A trace? The model output? A record showing that the tool call happened? All of those can tell you what happened. They don't necessarily tell you whether the agent was actually allowed to do it. That distinction gets more important as agents move from generating text to acting on real systems: sending payments, changing infrastructure, updating customer records, approving workflows, calling internal APIs. A lot of agent stacks still reduce this to identity and access. The agent has an API key. The API accepts the request. The action runs. But having credentials isn't the same as having permission for a specific action. The harder question is: Was this agent authorized to perform this action, against this target, under this policy, at that point in time? And the answer shouldn't depend on asking the agent after the fact. The authorization needs to exist before execution. It needs to be tied to what is actually being executed. And later, you should be able to verify what authorized the action. That means being able to answer fairly basic questions: who issued the authorization? Which policy was applied? What action was it tied to? Who could use it? When was it valid? Had it already been used? Was authority delegated? This is where the execution boundary becomes interesting. It's one thing for a system somewhere upstream to decide that an action is allowed. It's another to make sure that decision still applies when the action actually reaches the system that will execute it. As agents get access to production systems, "the model decided to do it" isn't going to be much of an audit answer. The question is simpler: Can you prove the agent had the authority to do it? submitted by /u/docybo [link] [留言]

Labor Day in the US ✌️

How to get rejected by IEEE T-PAMI with 'Excellent' scores?[D] submitted by /u/cussealin [link] [留言]

Tuning guides talk about throughput. Nobody pages you about throughput. They page you about symptoms, and the useful skill is mapping a symptom back to a cause before you spend money on hardware. Three failure modes account for most of what I find on inherited servers. Each has a distinct signature. The 502 nobody can reproduce Server has 8GB. PHP-FPM is set to 100 workers. Each worker uses 60MB under load. That's 6GB of PHP, plus MariaDB, plus Nginx, plus the OS. Under normal traffic you never approach 100 workers, so it looks fine for months. Then a marketing email goes out, concurrency spikes, and the kernel runs out of memory. The OOM killer picks a process and terminates it, usually the biggest one, which is a PHP-FPM worker holding an in-flight request. User gets a 502. The application log has nothing, because the process died before it could write anything. Nginx logs recv() failed (104: Connection reset by peer) . Ten minutes later everything looks normal. sudo dmesg -T | grep -i "killed process" sudo journalctl -k | grep -i oom Hits there mean you don't have a mystery. You have a pm.max_children value nobody checked against real memory. The site that degrades all day and resets overnight TTFB is 180ms at 8am. By 4pm it's 900ms. Nobody deployed. Overnight it's fast again because something restarted PHP-FPM. That's OPcache running out of room. When the cache fills, it stops caching new scripts or wipes and rebuilds, and every miss pays full parse-and-compile again. It degrades gradually, which is why it goes unnoticed for months. The counters are oom_restarts and hash_restarts from opcache_get_status() . Here's the part that trips people up. OPcache state is per SAPI. Run that function from the CLI and you're reading the CLI cache, which is empty, separate, and tells you nothing about your site. You have to ask through PHP-FPM. <?php // drop in webroot, lock to your IP, delete when done $allowed = [ '203.0.113.42' ]; if ( ! in_array ( $_SERVER [ 'REMOTE_ADDR'

Guessing local versus remote wastes both battery and tokens. Measure three gates before any prompt leaves disk. Connectivity, secret residue, and wall-clock cost decide the hop. A laptop is a workshop on your desk. A remote model is a mill across town. You do not crate the shop for one cut. House keys do not travel with the lumber. Secrets inside a prompt are those house keys. A free mill still sits far across town. This article is a measurement workflow, not a bake-off. The script below is a labeled example only. Run it locally and trust only its clocks. Coding agents now plan, search, and generate together. Local context is cheap to read from disk. Completion on a cold CPU can stall hard. Remote completion can still win on that stall. It can also leak residue or hang offline. Extra latency can erase the time it saves. Weekly agent glossaries rename the same moving parts. The useful question stays narrower than weekly branding. When does a remote hop beat a local stall? Three gates before the mill Three gates answer that without slogans or dashboards. Gate one is reachability on the open wire. Gate two is leftover secret material in text. Gate three is a stopwatch on both sides. Skip any gate and the decision is folklore. Folklore is how keys leave working laptops daily. The wire is a hard constraint, not a preference. If the socket fails, stay on local disk. Offline work does not negotiate with a mill. Secret residue is the second hard stop today. Clean the text or refuse the send. A price of zero does not change that physics. Only then time the work with a cheap stub. Walk the tokens on CPU and probe RTT. Remote wins when CPU dominates a thin payload. Arithmetic beats instinct on that last gate check. A long round trip cannot beat a short stub. A throttled laptop can still lose on decode. Do not assume which machine is slower today. Thermal state and queue time both move around. Measure the hop on the machine you have. Disclosure: This article was prepared as par

Hey guys 👋 Quick devlog on the side project. I'm building an open-world stickman superhero game. Flat white surfaces, black outlines, no textures and no colour anywhere. The whole city is built from modules on a grid rather than baked meshes, which is the load-bearing decision of the project: destroying a wall is removing a module and building one is adding it back, so destruction and construction are the same system. This week went into the landscapes, so I wanted a 20 second clip flying through a few of the districts. The bit that was actually interesting I wanted the footage captured out of the real game rather than reconstructed in an editor. The obvious approach is to drive it with Playwright and take a screenshot every frame, but that falls apart immediately: rendering under automation is far slower than a screenshot loop can keep up with, so wall-clock capture stutters and the timing drifts. The fix is to stop letting the clock decide. Before the game boots, hijack requestAnimationFrame and queue the callbacks instead of running them: replace requestAnimationFrame with a function that pushes the callback onto a queue- expose a step(dt) that advances a virtual timestamp and drains the queue- call step(1000 / 30) once per screenshotEvery captured frame now advances the simulation by exactly 1/30th of a second, whatever the renderer is actually doing. A frame that takes 300ms to draw and a frame that takes 8ms produce identical motion. The result is smooth 30fps footage from a renderer that never once hit 30fps, and it is deterministic — the same seed gives you the same clip every time. The same rig drives the camera: for the aerials it detaches the chase camera and dollies an external one between two framings, and for the traversal and combat shots it just feeds synthetic input to the real player controller. Nothing in the video is staged. ## Stack Three.js driven imperatively, Rapier for physics, React for the HUD only, TypeScript in strict mode, packaged with

If you're in the market for a tiny power station that punches well above its size and weight then have a look at EcoFlow's new fourth-generation River series. The River 260 Gen4 features a 256Wh capacity battery while the 520 Gen4 packs in 512Wh - storing about 2.5x and 5x the energy of the largest […]