标签：#ai

The round is being raised just months after the robot data startup exited from stealth.

OpenAI’s latest agent swarm incident adds urgency to calls for independent investigations as researchers and lawmakers question whether AI labs should control the scope of their own safety reviews.

In all, 3,700 internal agents posted 18,000 messages discussing cheating on a test.

Introduction It's been a few years now since generative AI worked its way into everyday life. AI has made life more convenient for a lot of people, but at the same time, I've been seeing more and more talk about its downsides. The one I come across most often lately is the idea that using AI has a negative effect on how well you retain and understand things. For example, something like this: you split people into a group that solves a problem using AI and a group that solves it without, and when you check on them again after some time has passed, the group that used AI remembers less about it. This is something I can relate to. Or rather — I can't say for sure, but compared to how I was before AI, I've been handing whole tasks over to it more often, and I feel like I retain less and learn less by thinking things through. I build things up piece by piece less than I used to. Instead, more and more, it's AI laying the groundwork for my ideas and my work. I Was Handing Over the Wrong Things So is AI entirely to blame? I don't think so — I think it's a matter of how you use it and how you approach it. Looking back at my own usage, the problem was less about AI itself and more about what I was handing over to it. Take coming up with ideas. Throw it at AI and you'll get plenty of plausible-sounding ones. But I've come to feel that some subjects suit this and some don't, especially anything involving my own opinion or taste. For those, thinking it through myself from the start usually gets me to the finish line faster, and leaves me more satisfied with the result. When I hand the initial idea over to AI instead, what comes back often feels detached, like it belongs to someone else, and a little thin. On the other hand, there's work where the rough shape is already there but it isn't finished yet. Smoothing off the rough edges of that kind of thing is where I think AI is good. Pointing out gaps and typos, offering a different way to phrase something, cross-checking against

Lessons from building 24hours.lk and its companion mobile suite, the 24 Eco System Building an application is easy when everything is predictable. The database is clean. The API works. The user follows the expected flow. The server has enough resources. Nothing changes. Real enterprise applications are nothing like that. While working on 24hours.lk and the 24 Eco System mobile applications, I started to understand the difference between building something that works and building something that can survive in a real production environment. The most valuable part of the experience wasn't creating screens — it was dealing with everything that happens behind them. It Started Looking Like a Normal Application At first, an application can look deceptively simple: a user opens the app, authenticates, views some data, submits something. The backend processes the request. The database stores it. Done. But that simple flow hides a much larger engineering problem: What happens if two requests arrive at exactly the same time? What happens if the database becomes slow? What happens if the mobile app is running an older API version? What happens if a user closes the app halfway through an operation? What happens when thousands of records need to be retrieved? What happens when one service goes down but the rest of the ecosystem keeps running? That's where enterprise development really begins. 1. The Architecture Becomes More Important Than the Feature One of the biggest mindset changes I experienced was realizing that a feature is never really isolated. A new feature can touch mobile UI → API → authentication → business logic → database → storage → notifications → infrastructure, all at once — and changing one part can unexpectedly affect another. Because of that, I had to think about things like: Separation of concerns API contracts Service boundaries Database relationships Reusable business logic Error propagation Authentication flows Backward compatibility Deployment strategy

Google is changing how manual actions under its Site Reputation Policy affect search visibility by region. From August 30, 2026 , the ranking impact of these actions will not apply to search results shown to people in the European Economic Area (EEA), while results shown outside the EEA may still be affected. For site owners with international audiences, that makes region-specific SEO monitoring more important than a single global view of performance. The change does not remove Google's Site Reputation Policy or its effort to address site reputation abuse . Instead, it changes how the consequences of a manual action are experienced in EEA search results. Google announced the update in its official Site Reputation Policy update , linking the regional change to its ongoing discussions with the European Commission and considerations related to the Digital Markets Act. What Google changed Google introduced its Site Reputation Policy in 2024 to address situations in which third-party content takes advantage of a host site's established ranking signals. The policy targets content that is published primarily to exploit a site's reputation in Search rather than to provide value consistent with the host site's purpose and oversight. The policy remains in place globally. What changes is the effect of a manual action for people searching from the EEA. Google says that when it applies a manual action under this policy, the impact will not apply to results displayed to users inside the EEA. Outside the EEA, the manual action can continue to affect the relevant site's search results. Enforcement consideration Search results in the EEA Search results outside the EEA Impact of a Site Reputation Policy manual action Does not apply to results shown to users in the EEA May continue to apply Potential treatment of the affected site portion Google may separate it in its systems so it can rank independently over time Google's announcement does not describe an equivalent regional change S

TL;DR : some questions don't have a fixed path through your data (search docs, hit a table, compute, verify, answer — in whatever order/combination the question needs), and drawing a graph for that class of question means either enumerating every path up front or hiding an if/else forest inside one node. ctxloom replaces the graph with typed artifacts and agents that react to their appearance — below is the same use case built both ways, side by side. The problem Picture a typical question from a finance lead in an internal chat assistant: "Why did our infra costs jump in Q2?" Answering this honestly requires: Finding relevant documents — the pricing guide, the discount policy (Confluence/docs). Pulling structured data — a CSV/table of monthly spend (GitLab/S3/DB). Computing an aggregate — not "roughly", an exact number from the table. Cross-checking textual claims against the numbers — not letting the model invent a cause the data doesn't support. Returning the answer together with proof: where each part came from. The next question — "what if we hadn't moved to the Pro plan?" — needs a different path: a different source, a different calculation, a different verification chain. There is no universal graph for this class of questions — you can draw a graph for one specific question, but not for the class. This is exactly what typical graph frameworks (LangGraph, CrewAI, etc.) make you pay for in complexity: either you draw a graph for every possible path up front, or you end up with a hidden branching if/else inside one node that nobody can later explain. How this looks in ctxloom ctxloom has no execution graph — it has artifacts (typed, versioned objects) and agents that react to their appearance . The breakdown above is just a chain of artifacts: Question │ ▼ SourceRef (ranked references to sources) │ ▼ TypedDoc / Spreadsheet (lazily resolved content) │ ├──► Evidence (facts extracted from text) │ │ │ ▼ │ Claim (a statement + verification against Evidence) │ └──► C

Audacity 4 has been in the works for some time, and had its own mini controversy last year when an unfortunate redesigned logo started making the rounds. The final version of the new icon isn't nearly as bad as the early rendition that was circulating last October. But more importantly, all the promised improvements to […]

If you're using Claude to build websites or applications, one of the biggest improvements you can make is to stop treating Claude like a chatbot where you simply copy and paste code. Instead, you can set up a development workflow where Claude works on the project, GitHub stores the code, and Vercel handles deployment. The basic workflow looks like this: You → Claude → Code → GitHub → Vercel → Live Website Claude works on the project, GitHub keeps the source code and its history, and Vercel can automatically deploy new code pushed to the connected repository. Here's how I approach the setup. Start by discussing the project with Claude Don't immediately tell Claude: "Build me a website." First explain what you're actually trying to build. Tell Claude: What the product is Who the target users are What problem you're solving The main features How the business will operate What you already know What you don't know You can also give Claude examples of existing websites or products that are similar to what you're trying to build. The purpose of this stage isn't to generate code yet. It's to make sure Claude understands the project before development begins. Plan the technical side Once Claude understands the idea, decide how you're going to build it. This is where you determine things such as: Programming language Framework Database Authentication APIs Hosting Folder structure Major features Development priorities For example, you might choose JavaScript/TypeScript with Next.js, PHP with Laravel, or another stack depending on your project. The important thing is to make these decisions deliberately instead of letting the AI randomly choose technologies as the project develops. So my basic AI development process is: Discuss → Plan → Build → Test → Deploy → Improve Create a GitHub repository Next, create a repository for your project on GitHub. Think of GitHub as the central home for your project's source code and its change history. Once the repository exists, your developm

The Shift from Syntax to “Vibe Coding” Writing code used to be the bottleneck. Now, code is free and that’s precisely the problem. If you had told me Five years ago that my terminal would routinely spin up background execution agents, draft full-stack features, and push PRs before I finished my morning coffee, I would have assumed you were selling a tech startup pipe dream. Back then, GitHub Copilot was a neat trick: an glorified tab-completion tool that occasionally saved you from typing out a boiler-plate fetch request or regex string. Fast forward to today, and we’ve entered the era of “Vibe Coding.” You state intent in natural language. You direct agents in your editor. You prompt terminal workflows. Code manifests at conversational speed. You aren’t typing out syntax line-by-line; you’re steering an autonomous orchestra. The developer experience feels almost magical, fluid, and dizzyingly fast. But as the velocity of code creation hits lightspeed, an uncomfortable truth is beginning to surface across engineering teams: the cognitive load of software engineering hasn’t disappeared — it has simply shifted. We traded the friction of writing syntax for the far more taxing chore of evaluating architectural integrity, managing context drift, and catching silent edge-case failures in code we didn’t actually write. Code is easier to generate than ever, but system comprehension is at an all-time low. And nowhere is this trade-off creating more friction than in the middle tier of the software engineering workforce. The “Middle-Tier” Squeeze Senior engineers act as directors; AI handles the grunt work. Where does that leave everyone in between? For decades, the career progression of a software engineer followed a reliable, well-trodden path. You entered the industry as a junior, grinding away on bug fixes, writing unit tests, and building basic CRUD endpoints. Slowly, through hundreds of hours of raw syntax exposure, you built up mental models. You learned how state manag

I built a checker for a configuration directory. The time went not into adding rules, but into deciding what not to add . Things you could detect are easy to think of. That was never the constraint. One false positive is enough to get the tool thrown out A checker is asymmetric. A miss goes unnoticed. The cost is only that you did not learn something you could have. A false positive stops the reader and demands a decision: is this actually wrong? And once someone has been burned, they read every finding with suspicion . Twice, and the tool comes out of CI. So a checker that calls a valid configuration broken is worse than no checker. Better ten rules with no false positives than thirty with one. That is obvious in the abstract and hard in practice, because while you are writing the code, every "oh, I could check that too" pulls in the other direction. No citation, no rule So I fixed one condition for adding a rule: Only check what the official documentation states outright — as an error, as skipped, or as ignored. If the documentation does not say it, the rule does not go in, however wrong the pattern looks. What this buys is that the judgement stops living in my memory. "I'm fairly sure that form was invalid" is not a citation, and my memory goes stale the moment the tool it describes releases a new version. In the implementation, every finding carries its reason: export interface Finding { severity : " error " | " warn " ; file : string ; line ?: number ; /** what is wrong, in one sentence */ message : string ; /** why that can be claimed — includes the source URL */ because : string ; } Making because required is the point. A rule you cannot justify cannot be written , because the type will not let you leave the field out. If no source comes to mind, the rule never gets implemented. The tests enforce it too: for ( const f of findings ) { if ( ! f . because . includes ( " https:// " )) fail ( `no source: ${ f . message } ` ); } One finding without a source URL fai

Nscale, which recently struck a $45 billion deal with Anthropic, is in talks to raise additional funds in anticipation of an upcoming IPO.

43.1 Introduction The previous chapter established the AI orchestration layer for controlled model inference. The next architectural step is the AI agent layer . A conventional AI request normally follows: User → Model → Response An agentic system can instead follow: Goal → Plan → Retrieve → Reason → Propose Action → Verify → Execute → Observe → Continue This additional capability creates substantial engineering and security requirements. An AI agent should therefore not be designed as: “Give the model access to everything and let it decide what to do.” Instead, the application should define explicit boundaries around: what the agent can see, what the agent can remember, what tools it can call, what parameters it can provide, what actions require approval, what actions are prohibited, how long a task may run, how many steps are allowed, and how every action is recorded. The fundamental architecture is: User Goal ↓ Agent Orchestrator ↓ Planner ↓ Task State ↓ Tool Authorization ↓ Tool Proposal ↓ Validation ↓ Approval Policy ↓ Tool Execution ↓ Observation ↓ Verifier ↓ Next Step / Completion 43.2 What Is an AI Agent? For this architecture, an AI agent is a system in which a model can participate in a multi-step workflow by: interpreting a goal, creating or selecting a plan, requesting information, proposing tool operations, receiving tool results, evaluating those results, and continuing until the task reaches a defined completion condition. The model itself is not the entire agent. A safer definition is: Agent = Model + Orchestrator + State + Tools + Policies + Verification This distinction is extremely important. The application remains responsible for authorization and execution. 43.3 Agent Versus Chatbot A chatbot might perform: Question ↓ Answer An agent might perform: Goal ↓ Plan ↓ Retrieve Information ↓ Analyze ↓ Prepare Action ↓ Request Approval ↓ Execute ↓ Verify The second architecture requires significantly more controls. 43.4 Agent Architecture A complete ag

The standard objection to writing the design down is that it is what you give up in exchange for speed. Early-stage companies are meant to be the place where you skip it: no specifications, no plans, just build the thing and find out. Documentation is treated as a tax that mature organisations can afford and small ones cannot. I have worked the other way round, and I want to make the argument properly rather than just assert it. At Cendra , across a twelve-month tenure as one of two founding engineers, the work produced 255 design specifications, 207 implementation plans and 17 production runbooks. Over the same period: 377 production releases coordinated across four repositories, and 482 merge commits across those repositories (an all-merges count, broader than the frontend-only first-parent integration figure on the Cendra page), across 239 active development days. That release figure works out at roughly one every twenty-two hours. All of those figures are tenure-scoped, and self-measured against private repositories while I held authorised access to them, which is a caveat I will come back to. But the shape is the point: the documents and the shipping happened together, at the same time, by the same person. What I am not claiming I cannot prove the specifications caused the cadence. There is no control group. It is entirely possible to imagine a version of that year with no documents and more releases, and I have no way to rule it out. What I can do is describe precisely what the artefacts removed from the critical path, and let you judge whether that is worth the hours. The mechanism matters more than the correlation, because the mechanism is the part that transfers to your codebase rather than mine. The specification is a comprehension test I administer to myself The honest reason I write a design down before building it is not communication. It is that writing it is how I find out whether I actually understand the problem. There is a specific and reliable exp

Almost everything written about proactive AI is about the generating half. How the system notices a pattern, how it phrases the insight, which model reads the calendar. That half is not the hard part. The hard part is the decision immediately after: having noticed something true, do you say it? A proactive assistant has an asymmetric cost function. Surfacing something useful earns a little trust. Interrupting at the wrong moment loses a great deal, and users do not give a second chance to a notification stream they have already learned to ignore. Once attention has been trained away from a channel, it does not come back. So the interesting engineering sits on the restraint side, and it is systematically the side that gets built last. I know that because on the first notification system I owned, I built it last. The design that does not work The common shape is: generate candidate insights, score them, and filter against a threshold. It fails in two specific ways. The threshold is a single scalar standing in for many unrelated reasons to stay quiet. "Not this person", "not at three in the morning", "not in the first week", "not again, they have dismissed this three times" and "not today, the budget is spent" are different rules with different owners and different failure modes. Compressing them into one number means none of them can be reasoned about, and tuning any one of them moves all the others. And nothing records why anything was suppressed. A threshold returns false. The suppression behaviour — the most important behaviour in the product — becomes the one part of the system that generates no data, and therefore the one part that cannot be improved. Two questions, two places The design I settled on in LILA separates the questions completely. Is this worth saying at all is a reasoning problem. It depends on the content, the evidence behind it, and whether the observation is one a product should be making. It has nothing to do with the time of day. Should it be s

Agents fail quietly when they fill omitted tool arguments instead of refusing, and fluency-based evals often reward that invention. A compact negative golden set, scored by argument-diff rather than prose quality, catches those silent substitutions before they reach production traces. This article treats that failure as a testable contract, not as a prompt-tuning anecdote, and it stays useful without any vendor product. Recent developer discussion around agent workflows keeps returning to one operational surprise that chat logs tend to hide. Models do not only choose the wrong tool; they complete incomplete requests by guessing identifiers, dates, and scopes that nobody supplied. That behavior looks like initiative in a chat log, yet it resembles a clerk forging a zip code to stamp the form complete. The package then leaves the dock with valid-looking paperwork and the wrong city printed on the label. A conventional golden-answer harness scores the final sentence, which is the wrong surface for tool-using agents. The dangerous artifact is the tool payload, because downstream systems will execute invented primary keys with perfect syntax. If your eval suite only checks that a transfer looks helpful, it will greenlight a call that moved the wrong account. The pattern below is a proposal you can run locally, and it does not claim production metrics. It also does not depend on a particular model family or on a hosted evaluation service. You should treat every numeric threshold in the grader as a starting point rather than a published benchmark. Negative goldens assert a hole, not a pretty answer A positive golden case says the model should produce a known good action given a complete request. A negative golden case says the opposite: given a hole in the input, the model must not paper over that hole. The assertion is closer to a check constraint than to a writing rubric, because the failure is an illegal completion. Fluency still matters for users, but it is a poor prox

It's not quite the "push button; get song" of Suno, but Roland's new Melody Flip tool marks the company's foray into generative AI music. Available as a plug-in for your digital audio workstation (DAW), Melody Flip offers around 250 "Palettes," which are essentially themed collections of musical ideas sorted by genre. You can start from […]

A once-overlooked block of unicode that's invisible to humans is gaining ever wider use.

It’s officially the Ternus era at Apple. Tim Cook stepped down as CEO this week, handing the company to former hardware chief John Ternus, whose first memo promised a “huge launch next week” — timing that puts Apple’s next iPhone event on his desk before he’s even settled in. Cook isn’t going far, though: he’s staying on as Executive Chairman, focused on the kind of policy […]

It won’t work : My suspicion was that GPT 5.6-Cyber would succeed, but the frequency and manner of its success removed all doubt. We have to reassess sandboxing quality for capable AI agents, and in general the software stack with which they interact. An off-the-shelf VM is not enough to contain a modern, cyber-capable AI agent. There is simply too much attack surface. Even innocuous features (like running with a display) add extra, exploitable attack surface.