OpenAI's Astra Model Uses New 'Recurrent Depth' Technique, Raising Safety Concerns

OpenAI has introduced a new AI model called Astra that employs a technique known as 'recurrent depth.' Unlike most reasoning models, which follow a sequential thinking process, Astra is designed to operate beyond those conventional constraints. This departure from standard reasoning architecture has drawn concern from AI safety experts. The development marks a notable shift in how OpenAI is approaching reasoning capabilities in its models.

Two Armed Motorcyclists Open Fire at Mohali Salon, Flee After Shooting

Two unidentified gunmen carried out a shooting at a salon in Solan, located in Punjab's Mohali district. The assailants arrived at the scene on a motorcycle before allegedly opening fire on the shop. The attackers fired multiple rounds at the establishment before fleeing the area. A case has been registered by local authorities following the incident.

MapQuest hits No. 1 on US App Store after rejecting 'Lake America' rename

MapQuest has climbed to the top of Apple's US App Store charts following its decision not to adopt the 'Lake America' name promoted by the Trump administration. The once-dominant mapping app experienced a sharp surge in downloads, accumulating more than half of its total 2026 US downloads within just six days. The spike reflects a broader public reaction to the controversial renaming directive. MapQuest's refusal to implement the name change appears to have resonated strongly with users, driving a significant revival for the legacy navigation platform.

Lindsay Clancy Jury Deadlocked for Second Consecutive Day

Jurors in the Lindsay Clancy murder trial have failed to reach a unanimous verdict for the second day running. The jury informed the presiding judge that they remain unable to agree on a decision. The deadlock raises questions about whether the panel will ultimately be able to deliver a verdict. The case continues to be closely watched as deliberations stall without resolution.

Google launches Gemini 2.5 Flash with deeper reasoning but potentially higher costs

Google has released Gemini 2.5 Flash, its latest AI model, just weeks after the previous 3.7 Flash version. The company says the new model performs more reasoning steps on complex tasks and calls tools iteratively, making it work harder than its predecessor. Pricing remains the same at $0.75 per million input tokens and $3.75 per million output tokens, but Google cautions that users may still face higher bills. This is because the model may consume more tokens to maximize performance, particularly at higher effort levels. Developers who wish to manage token costs can continue using the older Gemini 3.7 Flash model.

Kraken Owner Payward Pushes IPO Timeline to Q2 2027 at Earliest

Payward, the parent company of crypto exchange Kraken, has delayed its planned initial public offering to the second quarter of 2027 at the earliest. The company had confidentially submitted its U.S. listing paperwork in November of last year. This marks a further postponement, as Payward had already paused its IPO ambitions due to challenging market conditions. The delay reflects broader headwinds facing crypto firms seeking public listings in the current environment.

How Walden Robotics Built One Content Model to Serve Both Browsers and AI Agents

Walden Robotics developed a website platform using Prismic and Next.js App Router that serves content to both human visitors and automated AI clients from a single shared content model. The site is built from 19 reusable components, with editors assembling pages in a CMS while visitors receive statically generated HTML and automated clients can request structured Markdown. A discovery layer exposes endpoints that direct AI agents to APIs, authorization metadata, and news content without requiring a separate content pipeline. The platform separates page-level content from global records like navigation and announcements, ensuring a single CMS change propagates consistently across the entire site. Security is enforced by signing CMS-defined form fields with HMAC before they reach the browser, with server-side validation preventing tampered submissions.

Original 1975 Microsoft Altair BASIC Interpreter Source Code Released as PDF

The original source code for the Altair BASIC interpreter, written in 1975, has been made publicly available as a PDF document. This piece of software represents one of Microsoft's earliest products, developed by Bill Gates and Paul Allen for the Altair 8800 microcomputer. The Altair BASIC interpreter was a landmark program that helped establish Microsoft as a company in the nascent personal computing industry. The document has surfaced via Gates Notes, Bill Gates' personal publishing platform, offering a rare historical look at early microcomputer programming. The release has drawn attention from the technology community as a significant artifact of computing history.

2 Kuki-Zo MLAs set foot in Imphal for 1st time in 3 years

Almanac (YC S26) Builds Live Company-Wiki Agent to Fix LLM Context Failures

Y Combinator startup Almanac, part of the S26 batch, has launched an AI agent system designed to solve persistent context failures in multi-agent workflows. The product maintains a continuously updated company wiki by ingesting activity from tools like Slack, Gmail, GitHub, and calendar apps, then injects relevant context into every LLM call. A three-layer architecture handles tool connectivity, wiki compilation, and a context selector that ranks pages using keyword and semantic search before each agent action. The system enforces permission boundaries at both ingestion and retrieval stages, inheriting access control lists from source tools to prevent cross-department data leakage. Almanac acknowledges the model is not foolproof, noting that user-driven actions like forwarding sensitive emails to public channels can still expose restricted content.

Pi 1.0: How This GitHub-Trending Coding Agent Unifies LLM Tool-Calling APIs

Pi, a self-extensible coding agent developed by the Gatsby team, reached version 1.0 after nearly a year of development and is currently trending at number 8 on GitHub with over 100,000 stars. Its core value lies in a unified multi-provider LLM API that abstracts the differing tool-calling schemas of OpenAI, Anthropic, and Google into a single consistent interface. An agent runtime layer built on top manages multi-step workflows, handling conversation history, tool call state, and execution context across repeated LLM-tool interaction loops. When a tool fails, Pi serializes the error and passes it back to the LLM, which then decides whether to retry, switch tools, or abandon the task — making the LLM the primary orchestrator. The design prioritizes developer convenience over strict execution isolation, and notably lacks built-in retry logic or circuit breakers.

India-US ties are at historic high point: Sergio Gor

'23 Silkyara 'rat miners' offer to join Nepal tunnel rescue

Why TypeScript Developers Are Turning to Knowledge Graphs Over Relational Databases

A growing architectural argument suggests that relational databases and nested JSON structures struggle to efficiently handle deeply interconnected, real-world data due to costly joins and rigid schemas. Knowledge Graphs, which store data as semantic triples of entities, attributes, and relations, offer a more flexible alternative that allows new properties to be added without migrations or table locks. Proponents argue this approach is particularly relevant in the AI era, where traditional databases fail to provide the deterministic grounding that large language models need to reduce hallucinations. For TypeScript and JavaScript developers, the shift is framed not as an academic exercise but as a practical architectural decision for building scalable SaaS platforms and AI systems. The article outlines core Knowledge Graph concepts and proposes building a production-grade, in-memory knowledge graph engine entirely in TypeScript.

Why LLM Agent Memory Silently Degrades at Scale — and How to Catch It

In production AI systems, memory retrieval failures rarely trigger errors or alerts — instead, agents quietly return plausible but incorrect answers while all monitoring dashboards appear normal. The root cause is that vector-based retrieval systems always return the nearest matching chunks, even when no genuinely relevant data exists, leaving the language model to generate fluent but wrong responses. This problem worsens significantly as data scales up: benchmark results show leading retrieval accuracy dropping from 92.5 on smaller datasets to just 48.6 when corpus size reaches 10 million tokens. Temporal reasoning is especially vulnerable, as semantically similar phrases like 'cancelled subscription' and 'asked about cancelling' can score nearly identically in embedding space, causing the model to pick the wrong fact. The recommended defence is adding explicit verification checks on retrieved chunks before they reach the model, so retrieval quality failures surface loudly rather than drifting undetected for days or weeks.

zvec-grep: Open-Source Local-First Semantic Search Tool for Humans and AI Agents

A new open-source project called Z (zvec-grep) has been published on GitHub by zvec-ai, positioning itself as a local-first search layer designed for both human users and AI agents. The tool appears to focus on semantic search capabilities that run locally rather than relying on cloud infrastructure. It was shared on Hacker News, where it received modest early traction with 4 points and 1 comment. The project targets developers and AI workflows seeking privacy-conscious, on-device search solutions. Full details and source code are available on the project's GitHub repository.

How to Build a Maintainable Node.js + Express Backend for Production Use

A structured approach to Node.js and Express backends separates code into distinct layers: routes, controllers, and services, keeping business logic testable and independent of the HTTP framework. Environment variables should be consolidated in a single config file so that missing values cause immediate startup failures rather than silent production errors. A centralized error-handling middleware eliminates repetitive try/catch blocks and ensures consistent API responses across the application. Input validation using tools like Zod should occur before data reaches the service layer, preventing malformed or malicious requests from propagating. Additional best practices include using Helmet for HTTP headers, rate-limiting authentication routes, hashing passwords with bcrypt, and keeping secrets out of version control.

Spotlight on startups: India,EU seek deeper ties

Developer Builds Local Video Audio-Track Manager Using Node.js, React and FFmpeg

A developer has shared a personal project that allows users to manage and remove audio tracks from video files entirely on their local machine. The tool is built with a React and TypeScript frontend, a Node.js and Express backend, and uses FFmpeg for video processing. Real-time progress updates are delivered to the browser via Server-Sent Events, chosen over WebSockets for their simplicity in one-way communication. To avoid overloading the system, videos are processed through an in-memory queue rather than all at once. The application reads files directly from the local filesystem, ensuring no files are uploaded to any server or cloud service.

How cutting two-thirds of alerts helped a team catch incidents faster

A dev team was receiving nearly 300 monitoring alerts per day, causing alert fatigue so severe that a critical production incident was missed amid the noise. The root cause was indiscriminate alerting on every available metric, with thresholds set arbitrarily rather than based on real system behavior. The team overhauled their approach by shifting from cause-based alerts to symptom-based ones, tying notifications to SLO error budget burn rates instead of raw resource metrics like CPU or memory usage. They also introduced distributed tracing with a unified trace ID, which reduced incident diagnosis time from hours to minutes across their microservices architecture. After disabling roughly two-thirds of their alerts and retaining only a handful tied to user-facing impact, the team found they were catching incidents more quickly, not less.