标签：#ai

Travel bans and other visa issues are creating problems for World Cup participants even before the whistle blows.

Ask a large language model for a specific statistic, then ask where it found that number. More often than not, the citation it gives you doesn't exist. The model will hallucinate a plausible-looking reference, confidently present outdated conclusions, or simply make things up without any internal signal that something is wrong. This failure mode has a well-known name — hallucination — and the most widely adopted engineering solution for it is RAG. RAG in One Sentence RAG stands for Retrieval-Augmented Generation. The idea is straightforward: before the LLM generates an answer, retrieve relevant document chunks from an external knowledge base, then feed those chunks to the model as context so it can compose its response based on real source material rather than parametric memory alone. Think of it like writing a research paper. You don't cite statistics from memory; you look them up first, then write your argument around verified data. RAG gives language models the same "look it up, then write" workflow. Three Structural Limitations of LLMs To understand why RAG is necessary, we need to identify the specific gaps it fills. Knowledge cutoff. Every model has a training data deadline. GPT-4's cutoff is late 2023; Claude's is early 2025. Anything that happened after that deadline simply doesn't exist in the model's world. It will either admit ignorance or, more dangerously, fabricate an answer that sounds current. Bounded parametric capacity. Even a 100-billion-parameter model can only "memorize" so much. Long-tail facts, niche domain knowledge, your company's internal documentation, yesterday's meeting notes — none of these are in the weights. No built-in fact-checking. Token generation is probabilistic sampling. The model has no mechanism to distinguish whether it's recalling a training fact or pattern-matching its way into a plausible-sounding fiction. RAG addresses all three: it supplies up-to-date, verifiable, externally sourced evidence at inference time. How RAG W

Every tool sprawl thread I read starts with license math, and license math is a decoy. Last quarter I added up what our seven-tool delivery stack actually cost us, and the subscriptions came to about 15% of the total. The other 85% never appears on an invoice, which is exactly why nobody budgets for it and nobody fixes it. Some background so you can judge whether my numbers transfer to your team. I spent years building automation in banking before running my own product team, so I am professionally allergic to process waste. Despite that, our stack had drifted into the usual shape: Jira for tickets, Confluence for docs, Lucidchart for architecture, TestRail for test cases, two spreadsheets doing unpaid overtime in the gaps, and an AI chatbot bolted on the side that had never seen any of it. The licenses for all of that, for six people, ran about $700 a month. Annoying. Not a crisis. And that is precisely why the "consolidate your tools" pitch dies in so many budget conversations. Saving a few hundred dollars a month does not justify a migration, and everyone in the room knows it. If licenses were the real cost, I would side with the skeptics. The audit: two weeks of logging every re-key So we measured the part nobody measures. For two weeks, everyone on the team logged every re-key: any moment a human moved or restated information that already existed in another tool. Copying acceptance criteria from Confluence into a Jira ticket. Updating TestRail because a story changed shape. Redrawing a Lucidchart flow that had drifted from the code. Reassembling a status update by hand from three tabs. Pasting project context into the chatbot, again, because it forgot everything since yesterday. The rules were strict so the number would survive scrutiny. Log transfer time only, not thinking time. Round down when unsure. If the same fact got re-keyed twice, log it twice, because it cost twice. Each entry went into a shared CSV with four columns, and this script turned it into th

Playwright has excellent tooling around browser automation, but most of the ecosystem still treats it as a test framework. For teams running AI coding agents and automated browser workflows, there is a different set of requirements: browser automation ↓ session persistence across runs ↓ debuggable traces when things go wrong ↓ parallel execution across CI shards The Playwright CLI directly addresses these gaps. It ships as a standalone npm package and exposes every browser operation as a CLI command; open, click, type, snapshot - without requiring a Node.js script or test runner. npm package: @playwright/cli GitHub: https://github.com/microsoft/playwright-cli The current implementation focuses on: session persistence with named instances and portable state video and trace recording built into every session CI sharding for parallel execution at scale session persistence The default behaviour keeps browser state in memory. Cookies and localStorage are preserved between CLI calls within the session, but cleared when the browser closes. For repeatable workflows, that breaks down fast — logging into an application before every run wastes time and introduces flakiness. Named sessions let you run multiple browser instances simultaneously and address them by name: playwright-cli -s=admin open https://app.example.com/admin playwright-cli -s=checkout open https://app.example.com/checkout Each session is an isolated browser instance. An agent can orchestrate workflows across multiple authenticated contexts without state leaking between them. The goal is straightforward: the same CLI binary should be able to maintain independent browser contexts for parallel workflows without requiring environment-specific configuration. The critical piece for CI and agent reuse is state persistence: log in once playwright-cli -s=admin open https://app.example.com/login playwright-cli -s=admin fill "#username" "admin" playwright-cli -s=admin fill "#password" "$ADMIN_PASS" playwright-cli -s=admi

I’ll say it plainly: the first health-adjacent agent workflow I’d trust is not an AI doctor. It’s a narrow pipeline that takes 6 months of Apple Watch sleep data, cleans timestamps, maps records into a fixed sleep-diary schema, flags broken rows, and stops for human review before anything reaches a clinician. That sounds unsexy. Good. That’s exactly why it’s the first version I’d trust. I landed on this after reading a post on r/openclaw where someone said they had their AI assistant turn months of Apple Watch sleep data into the diary their sleep clinic requested, and the data gotchas were brutal. That sentence contains the whole product. Not “AI healthcare.” Not “autonomous wellness.” Not a GPT-5 wrapper with a soothing UI pretending it understands sleep medicine. Just a very practical engineering problem: parse ugly export data normalize time boundaries fit it into a clinician-friendly format fail loudly on bad rows require a human to approve it That is a real use case. And if you build automations in n8n, Make, Zapier, OpenClaw, or Python, it should feel familiar: the hard part is not the final prompt. The hard part is the ugly middle. The hard part is ETL, not reasoning Most health-agent demos skip the only part that matters. They show the polished summary. They show Claude or GPT-5 saying something calm and articulate. They show a dashboard. I don’t think that’s the hard part. The hard part is ETL: extraction transformation loading For sleep data, that means dealing with stuff like: timestamps crossing midnight timezone normalization naps vs overnight sleep missing start or end times overlapping intervals gaps from the device not recording clinic-specific diary formats If you get any of that wrong, the model summary at the end is not helpful. It is actively misleading. That’s why I think the boring pipeline is the real product. The workflow I’d actually ship If I had to build this today, I would keep the architecture aggressively narrow. Apple Health export ->

My CV is a PDF, and PDFs do not answer questions. So I built ask.hiten.dev : a streaming chat grounded in my actual career history, where a recruiter can ask "why should I hire you over another senior frontend engineer?" and get a real answer. The constraint that made it interesting: the total inference budget is zero. No OpenAI bill, no hosted vector DB, nothing. Here is what that actually took. Four free providers and a failover chain No single free tier is reliable enough to put in front of strangers. Groq's free tier caps at 100k tokens/day, and I hit that cap on day one. OpenRouter's free models come and go. Cerebras occasionally queues you out at busy times. The fix is boring and effective: an ordered provider chain, all OpenAI-compatible, walked per-request until one answers. Groq (llama-3.3-70b) -> OpenRouter (gpt-oss-120b:free) -> NVIDIA (llama-3.3-70b) -> Cerebras (gpt-oss-120b) Each provider is just a base URL, a key and a model name. The API route tries each in order; the first 2xx with a body wins, and the response streams straight through. The client gets an X-Provider header so I can see who served what in the logs. Two details that mattered: Empty env vars are not unset. Docker Compose's ${VAR:-} yields an empty string, which defeats ?? defaults in Node. Every key goes through a helper that coerces "" to undefined , otherwise a provider with no key "exists" and fails every request. You cannot cheaply probe a token-per-day cap. My health check hits GET /models on each provider (auth check, 60s cache). It tells you "key works, service up", not "you have tokens left". The failover chain covers the gap: a TPD-capped provider fails fast and the next one picks up. If every provider is down, the page itself says so. The health check runs server-side at render time, and instead of a broken chat you get a short maintenance note. Never ship a chat UI that can fail after the user has typed. Open-weight models do not follow formatting orders My site's voice avoi

OpenAI's GPT-5.5, GPT-5.4, and Codex are now generally available on Amazon Bedrock, one month after OpenAI revised its exclusive Azure arrangement. Pricing matches OpenAI's direct rates with usage counting toward AWS commitments. Codex shifts to pay-per-token billing with no seat fees. GPT-5.4 is the first OpenAI model available in AWS GovCloud. By Steef-Jan Wiggers

Anthropic is walking back a hidden policy that researchers say sabotaged their work.

Deezer will now scan your playlists on other streaming platforms to detect AI-generated music. Deezer was the first of the big streaming services to start labeling AI-generated music. It even offered its tech to other platforms, but it doesn't seem like it had many buyers. Qobuz launched its own detection tech, while Apple and Spotify […]

OpenAI has published a report detailing how China-linked influence campaigns against data centers used ChatGPT.

AI coding tools are changing how software gets built. Claude Code, Cursor, GitHub Copilot, Windsurf and other tools can generate code incredibly fast. For small tasks, they are already useful: write a component, explain a function, scaffold an endpoint, create a test, refactor a file. But after using AI in real projects, one thing becomes obvious: The problem is no longer code generation. The problem is engineering control. Most AI coding workflows still look like this: text idea -> prompt -> code -> fix -> prompt again -> more code -> lost context -> start over It feels fast at the beginning. Then the project grows. Requirements change. Architecture decisions disappear inside chat history. The AI forgets previous context. You start acting as product manager, architect, reviewer, QA, DevOps, and prompt engineer at the same time. That is not software engineering. That is vibe coding. ## Vibe coding works until it doesn't Direct AI coding is great when the task is isolated. Ask for a React component. Ask for a SQL query. Ask for a utility function. Ask for a unit test. No problem. But real software is not a collection of isolated snippets. Real software has: - business rules - architectural constraints - existing patterns - security concerns - database impact - deployment requirements - edge cases - regression risk - long-term maintenance When AI jumps directly from prompt to code, it often skips the thinking that should happen before implementation. The result may compile. But does it fit the architecture? Does it respect the domain? Does it create hidden technical debt? Does it solve the right problem? That is the gap we are trying to close with N45.AI. ## What is N45.AI? N45.AI is a framework that turns AI coding tools into a structured engineering workflow. It works with the tools developers already use, including Claude Code, Cursor, GitHub Copilot, and Windsurf. The idea is simple: Instead of treating AI as one generic assistant, N45.AI organizes the work like a

A useful thing happened in agent infrastructure this June: several teams shipped "escrow layers for AI agents" - production MCP tools that let an agent run a full commit -> hold -> complete lifecycle without a human anywhere in the loop. An agent can now park value with a contract or service, wait for the other side to deliver, and release on completion. That is genuinely new, and it solves a real problem. It is also worth being precise about, because "escrow" and "settlement" get used as if they were one thing. They are not. There are two structurally different ways to make a trade your agent does at 3am trustworthy, and the difference is exactly who holds the money while the trade is in flight . Model one: held custody In the held-custody model, a third party - a smart contract escrow, a custody service, a payment facilitator - takes the funds, holds them, and releases them when a condition is met. The condition can be anything you can express: a delivery confirmation, an evaluator's attestation, a timeout, a multi-sig approval. This is the right tool for a large class of agent commerce. If your agent is paying a merchant, buying a dataset, or hiring another agent to do a unit of work, the hard question is subjective : did the thing actually get delivered, and was it any good? A hash function cannot see that. A custodian can - it gives the trade a place to pause while something or someone checks. The new agent-escrow tooling is built around exactly this shape: a job, a held balance, a release on completion. For agent-to-merchant payments riding on rails like x402, held custody is the honest primitive. The cost is equally concrete. A held balance is a honeypot. Someone controls the funds between commit and complete, which means someone can freeze them, lose them, misconfigure the release condition, or get drained. You have added a trust assumption and a liveness dependency - the custodian has to be online, solvent, and honest at release time. That is often an accep

My daughter Emma is 11. She's been vibe coding lately, and honestly, she's pretty good at it. The...

It is a privacy-first, local-first photo organizer powered by deep learning face recognition. It detects, embeds, and groups faces to organize your photos automatically—all 100% offline. 🔥 Highlight Features: ✅ 100% Local: No cloud APIs, no telemetry, no leaks. ✅ Deep Learning: Driven by OpenCV DNN (YuNet + SFace ONNX models). ✅ Smart Automation: Copies matches, partial matches, and individual profiles into organized folders, complete with ZIP archives and JSON reports. ✅ Standalone EXE: Run it on Windows instantly with zero dependencies. ✅ Dynamic UI: Fully responsive Tailwind dashboard with Dark/Light modes. Check out the repository, download the EXE, or contribute: 👉 https://github.com/Shaan-alpha/face-sort-studio Let me know what you think! ⭐ machinelearning #computervision #python #localfirst #privacy #developers #opensource #ai Internet access on first launch only (to fetch the AI models ~40-50mb)

TLDR: we just launched free OpenClaw hosting. One-click deploy, no infrastructure to manage, only pay...

The decision comes as India emerges as the world’s largest GCC market.

If you doubted his genius, doubt no more.

If you've ever tried to use an AI resume builder, you've probably hit the same wall I did. You sign up, poke around, find the one feature you actually need — and then boom: "Upgrade to Pro for $29/month." It's frustrating. Resume help shouldn't be locked behind a paywall. So I built my own. Meet Persona Persona is an AI-powered resume builder that you run completely on your own machine . No deployment required. No subscription. No account on some third-party service. You clone the repo, set it up, and it's yours. It's a fork of the excellent open-source project ResumeLM , but I've added a bunch of features I couldn't find anywhere else — especially around local AI and template variety. 👉 GitHub: github.com/nithiin7/persona (Drop a ⭐ if you find it useful!) The Big Deal: Run AI Completely Offline with Ollama This is the feature I'm most proud of. Most AI resume tools call out to OpenAI or Anthropic and charge you for every request. Persona supports Ollama — which means you can run the AI model locally on your own hardware, with zero API costs and zero data leaving your machine. Here's how simple it is: Install Ollama on your computer Pull any model ( ollama pull llama3 , for example) Open Persona's settings, point it to your local Ollama URL Done — the AI now runs entirely on your machine No OpenAI key. No Anthropic key. No usage limits. Your resume data never touches an external server. If you do want to use cloud models, Persona supports those too — GPT-5, Claude Opus 4.7, Claude Sonnet 4.6, and a handful of open-source models via OpenRouter. But the Ollama path is what makes this genuinely different from everything else out there. It's 100% Free — Everything Unlocked The original ResumeLM had Stripe payments baked in. I ripped all of that out. Every single feature in Persona is available to every user, always. There's no "Pro plan." There's no feature gating. You self-host it, you own it, you use all of it. 10 Resume Templates Persona ships with ten distinct templ

I built a knowledge graph out of my own work sessions. Hundreds of them — transcripts of me building a system with LLMs, extracted into concepts, decisions, findings, and the edges between them. For a while it felt like the thing was working. I'd query it, get back a clean structured answer, and move on. Then I ran a foreign model against it. I gave a different model my concept definitions and asked it to reconstruct the system, both the vocabulary and the relationships. It recovered 97.7% of the words. It recovered 61.1% of the structure. That 36-point gap was the first time I could see the problem instead of just living inside it. The vocabulary transferred because the definitions were written carefully. The edges didn't, because the edges were the part I'd let the extraction handle. And the whole time, querying the graph had felt complete. The structure came back typed, connected, confident-looking — so I stopped looking. I started calling it premature retrieval closure: the retrieval returns something shaped like a whole answer, which is exactly why I didn't notice the parts that were missing. Part 10 of Building at the Edges of LLM Tooling . If you're running a long-term project through an LLM-backed memory system (anything that turns raw sessions into structured, persistent memory), this is about the step where the structure starts lying about how complete it is. Start here . Why It Breaks Every memory system of this kind does the same move. An LLM reads raw interaction (a conversation, a document, a session log) and lifts structured memory out of it: entities, facts, rules, summaries. That structured memory becomes the thing the agent reads later, instead of the raw record. The lift is where fidelity goes. Pulling clean structure out of messy text means making decisions the text didn't make explicit: which entity this pronoun refers to, whether a relationship is real or inferred, what to keep and what to drop. Those decisions can be wrong, and when they are,

After 8 months of daily Claude Code use, I've distilled my workflow into a 5-layer system. Each layer builds on the previous one. Skip one, and the whole thing falls apart. The Problem with Most Claude Code Users Most people use Claude Code like ChatGPT — open terminal, ask a question, close, repeat. The next day, they explain their project from scratch. Again. The symptom: 20% of every session is wasted on context re-establishment. The root cause: No project memory, no workflow discipline. Here's the system that fixed it for me. Layer 1: CLAUDE.md — Your Project's Memory Anchor This is the foundation. Without it, nothing else works. CLAUDE.md is a file at your project root. Claude reads it automatically at the start of every session. It tells Claude: What this project is (one sentence) The tech stack (specific technologies, not "Python web framework") The architecture (the big picture you'd need 3 files to understand) Unique conventions (not generic advice like "write tests") Quality priorities Bad CLAUDE.md (you've probably written this): # My Project A web application built with Python and FastAPI. ## Development - Write clean code - Add unit tests - Use Git This tells Claude nothing it doesn't already know. Good CLAUDE.md: # CLAUDE.md ## Project Overview Internal RAG knowledge base serving 500+ employees. ## Tech Stack FastAPI + LangChain + Milvus + PostgreSQL + Redis ## Commands - Start: `uvicorn app.main:app --reload --port 8080` - Test: `pytest -x --cov=app --cov-report=term-missing` ## Architecture Request flow: router → service → retriever → Milvus → generator → LLM API Key directories: - app/router/ - API layer - app/service/ - Business logic orchestration - app/retriever/ - Retrieval strategies (vector/BM25/hybrid) - app/generator/ - LLM calls and prompt management ## Key Conventions - All APIs return `{"data": ..., "error": null}` - Retrieval results MUST include source field - Milvus collection naming: `{env}_{doc_type}` The rule: Only write what's uniq