标签：#ai

I Benchmarked Lynkr Against LiteLLM on the Same Backends. Lynkr Was Cheaper for Tool-Heavy Workloads Founder disclosure: I built Lynkr, so take this as a technical benchmark write-up, not a neutral industry report. The numbers below come from the same backend providers on both gateways. If you're routing AI coding traffic through a gateway, just switching providers is not enough. The real savings come from reducing the tokens that ever reach the model in the first place. I ran Lynkr and LiteLLM against the same backends — Ollama locally, Moonshot, and Azure OpenAI — across 9 scenarios. On the scenarios that actually look like agentic coding work, Lynkr was cheaper because it does three things before forwarding the request upstream: smart tool selection, TOON compression, and semantic caching. The short version Lynkr was measurably better on the cost-sensitive parts of the workload: Smart tool selection: 53% fewer input tokens, 52% lower cost TOON JSON compression: 87.6% fewer billed tokens on a large tool result, 50% lower cost Semantic cache: 171ms cache-hit response vs 3,282ms on the repeat query path Tier routing: escalated hard prompts to stronger models instead of blindly sending everything to the cheapest route Area Lynkr result Why it mattered Tool selection 53% fewer tokens Removes irrelevant tool schemas TOON compression 87.6% fewer tokens Shrinks large JSON tool outputs Semantic cache 171ms cache hit Avoids repeat model calls Tier routing Escalates hard prompts Doesn’t over-optimize for cheapest path This matters if you're running Claude Code, Codex, Cursor, or similar agent workflows where tools, file reads, grep output, and repeated context dominate your token bill. Setup Same benchmark inputs, same providers, same request shape. Machine: macOS on Apple Silicon Lynkr: v9.3.2 on Node 20 LiteLLM: v1.87.1 on Python 3.12 Backends used: Ollama local, Moonshot, Azure OpenAI Scenarios: 9 total across simple prompts, tools, history, cache, and routing Each scena

We live in an era where scientific breakthroughs are published faster than we can read them. For the biohacking community, the gap between a new PubMed study on NAD+ precursors and actually knowing what dose to take is a chasm of manual research. What if you could build an LLM Agent that monitors research papers, processes them through a RAG (Retrieval-Augmented Generation) pipeline, and maps findings to your specific health profile? In this tutorial, we are building Paper-to-Action , a state-of-the-art agentic workflow using LangGraph , ChromaDB , and Mistral-7B . This isn't just a simple bot; it's a multi-stage reasoning engine designed to turn raw academic data into actionable health interventions. If you've been looking to master AI agents and personalized medicine automation, you’re in the right place. 🚀 The Architecture: From Raw Paper to Personalized Habit Traditional RAG pipelines are linear. To handle the nuance of medical research, we need a "looping" logic. We use LangGraph to manage the state of our agent, allowing it to decide if a paper is relevant before attempting to extract a protocol. System Flow graph TD A[Start: Keyword Trigger] --> B[Search PubMed/Arxiv API] B --> C{Relevance Filter} C -- No --> B C -- Yes --> D[Store in ChromaDB] D --> E[RAG: Extract Intervention Protocol] E --> F[Cross-Reference with User Profile] F --> G[Generate Personalized Action Plan] G --> H[End: Push to Health Checklist] Prerequisites To follow this advanced guide, you'll need: LangGraph : For the agentic state machine. ChromaDB : As our high-performance vector store. Mistral-7B : Running via Ollama or vLLM for local, private inference. Python 3.10+ Step 1: Defining the Agent State In LangGraph, everything revolves around the State . We need to track the fetched papers, the extracted data, and the final recommendation. from typing import Annotated , List , TypedDict from langgraph.graph import StateGraph , END class AgentState ( TypedDict ): keywords : List [ str ] user

Back in 2015, the two-person studio Metanet released N++, a brutally hard 2D platformer that was a decade in the making, building off of previous releases dating back to the freeware Flash title N. At the time, cofounder Raigan Burns issued some famous last words: "We hope it's not another 10 years before we come […]

Who's afraid of the next GTA? Based on the last few days of Summer Game Fest, just about everyone. Grand Theft Auto VI hasn't been present at any of the keynote events, but its presence was felt every time a release date was announced. The month of November, when GTA VI launches, is virtually empty. […]

Square Enix has officially announced the third and final game in its Final Fantasy VII remake trilogy: Final Fantasy VII Revelation. It will release on multiple platforms simultaneously - PC, PS5, Xbox Series X / S, and Nintendo Switch 2 - in spring 2027. In footage shown onstage at Summer Game Fest Live, there was […]

After a very profitable decade on Microsoft's board, Reid Hoffman is stepping down to focus on his AI drug discovery startup Manus.

A massive viral conversation sharing VC horror stories has taken place this week on X. Some are weird. Some are infuriating.

Chronologically, Control Resonant is a sequel to 2019's Control. But in most other ways, the games aren't directly connected. To developer Remedy, they're more like two sides of the same coin. When Resonant was first revealed last year, creative director Mikael Kasurinen said you can play the games in any order. The world of Control […]

While some of my recent posts have involved using the Colab extension for VS Code and the Antigravity IDE, I actually prefer working in the terminal and Vim. The new Colab CLI finally lets me work in my natural habitat, and it opens the door for autonomous workflows! Setup Currently, installation is handled via pip or uv. It's straightforward, though, I'm holding out hope for a brew formula in the future: uv tool install google-colab-cli I'm testing Version: 0.6.dev7+g510115b0c inside Ghostty. The Colab CLI is pretty solid, but I do have some feedback and nitpicks I'd like to share (but more on that later). Creating a new session Creating a session is simple: colab new [-s SESSION_NAME] [--gpu T4|L4|A100|H100] [--tpu v5e1|v6e1] : SESSION_NAME : This is optional. If you leave it blank, the CLI generates a random unique ID for you. --gpu and --tpu : The hardware accelerator flags are optional, but omitting them defaults to a standard CPU-only instance. The specific accelerator chips you can request depend on your Colab tier, which you can check via colab pay. NOTE : If you only have one active session, the CLI targets it by default. This makes the -s flag unnecessary for subsequent commands. Testing Colab CLI's capabilities CLI certainly sounds cool, but how does it handle artifacts and images? More importantly, how debuggable is it? I decided to find out by running a Fashion MNIST PyTorch example. Handling artifacts To get started, I installed my requirements using colab install torch torchvision matplotlib . If you prefer a more standard approach, you can also use colab install -r requirements.txt . Once the environment was ready, I executed the training script using colab exec -f ./fashion_mnist_TRAIN.py and here's the output: [ colab] Using unique session '8c860c' . Using CUDA device. Shape of X [ N, C, H, W]: torch.Size ([ 64, 1, 28, 28] ) Shape of y: torch.Size ([ 64] ) torch.int64 NeuralNetwork ( ( flatten ) : Flatten ( start_dim = 1, end_dim = -1 ) ( linear_re

I and I imagine a lot of other folks, don't believe the future of work should be a smaller group of executives commanding a larger system of people and machines. We have seen what AI can do not just to software product quality without guardrails, but to the junior and midlevel team members who are laid off or never hired at all in exchange for better profit rates with AI tokens vs human salaries. That is just the old hierarchy with better software. The history of work has always had this tension. You can go back to the start of US history and look at the military, commissioned officers were trained and trusted to command while enlisted service members carried out the work and risk. In the corporate and business world, executives and managers became the people who planned, measured, and optimized, while workers became the people being measured. Those structures were not only about class, but race and in America they were built inside a society already shaped by racism, classism, unequal education, unequal access to capital, and unequal access to leadership. AI now forces us to confront that history again. If we are not careful, AI will not flatten organizations. It will make the hierarchy invisible. Instead of a manager with a clipboard, we will have an algorithm. Instead of a foreman with a stopwatch, we will have dashboards, productivity scores, automated performance reviews, and AI systems that decide who gets opportunity and who gets replaced. That is not progress. The goal should not be to replace people with AI. The goal should be to replace bureaucracy, repetitive work, bad process, and unnecessary gatekeeping. What I am trying to do at Buildly is simple: AI should remove drudgery, not dignity. Automation should increase agency, not surveillance. Productivity gains should be shared, not extracted. Hierarchy should be functional, temporary, and accountable — not a measure of human worth. This is why we talk about AI-native product development differently. An AI

Dropbox Nova for AI Coding Agents, OpenAI's Codex Sandbox, & Puppeteer MCP Server Today's Highlights This week, we dive into Dropbox's Nova platform for scaling AI coding agents and OpenAI's secure sandbox architecture for Codex, highlighting advanced production deployments. We also examine practical solutions for safer browser automation for AI agents, detailing a custom Puppeteer MCP server. Dropbox Introduces Nova, an Internal Platform for Running AI Coding Agents at Scale (InfoQ) Source: https://www.infoq.com/news/2026/06/dropbox-nova-ai-coding-agents/?utm_campaign=infoq_content&utm_source=infoq&utm_medium=feed&utm_term=global Dropbox has unveiled Nova, an internal platform meticulously engineered to orchestrate and scale AI coding agents. This platform tackles the complex challenges of managing autonomous AI entities performing tasks like code generation, bug fixing, and refactoring across a large codebase. Nova's architecture focuses on reliability, efficiency, and safety, providing a robust environment for thousands of agents to operate concurrently without overwhelming system resources or introducing instability. The platform acts as a critical layer between AI models and the vast codebase, enabling agents to interpret development tasks, interact with repositories, and propose changes in a controlled manner. The significance of Nova lies in its ability to industrialize the use of AI in software development workflows. By abstracting away the operational complexities of agent deployment and execution, Dropbox empowers its engineering teams to leverage AI as a force multiplier, accelerating development cycles and improving code quality. Nova represents a practical, large-scale implementation of AI agent orchestration, demonstrating how companies are moving beyond experimental AI tools to integrate them deeply into core business processes. This showcases a production-grade pattern for applied AI, particularly relevant for "code generation" and "workflow automati

Every week I see the same question in AI governance communities: "We already have NIST AI RMF implemented. Does that cover our EU AI Act obligations?" The honest answer is: sometimes yes, sometimes partially, and sometimes not at all. The problem is that nobody had built a clean, free, interactive tool that showed exactly which controls map to which, how strong those mappings actually are, and where the genuine gaps are. So I built one. Live tool: suhanasayyad.github.io GitHub: SuhanaSayyad / eu-ai-act-crosswalk-tool Interactive crosswalk mapping EU AI Act obligations to NIST AI RMF and ISO 42001 controls, with mapping strength indicators, gap analysis, and source links. 30 controls mapped. Free and open source. EU AI Act × NIST AI RMF × ISO 42001 - Interactive Compliance Crosswalk Tool An open-source tool that maps EU AI Act obligations to their equivalents in NIST AI RMF and ISO 42001, with mapping strength indicators, gap analysis, and source document links. Built for compliance teams, AI governance practitioners, and anyone trying to understand how these three frameworks relate to each other. Live demo: https://suhanasayyad.github.io/eu-ai-act-crosswalk-tool Built by: Suhana Sayyad | MSc Cybersecurity, TUS Athlone Why I built this Every organisation dealing with the EU AI Act is being asked the same questions: "We already have NIST AI RMF controls in place. Does that cover our EU AI Act obligations?" "We're pursuing ISO 42001 certification. Does that satisfy the regulation?" The honest answer is: sometimes yes, sometimes partially, and sometimes not at all. The problem is that nobody had built a clean, free, interactive tool that showed exactly which… View on GitHub What the tool does The EU AI Act / NIST AI RMF / ISO 42001 Interactive Crosswalk Tool maps 30 EU AI Act obligations to their nearest equivalents in NIST AI RMF and ISO 42001. For each mapping it shows a strength rating - Strong, Partial, Indirect, or No Equivalent - so compliance teams know which map

been building AI agent infrastructure for the past few months. The two things that kept biting me — and kept coming up when I talked to other devs building agents — were runaway costs and agents doing irreversible things without asking first. So I built gvnr: an open-source MCP server that gives agents per-agent spend caps (hard-stop before a call if the budget's gone) and a human approval gate (agent asks, you get a mobile link, you approve or deny, agent waits). Both work as plain REST calls or MCP tools — no platform to adopt, no SDK. It's live. You can get an API key in one curl command and try the approval gate for free (it doesn't burn the trial ops). Source is at github.com/mightbesaad/gvnr . Here's what I genuinely want to know from devs building in this space: Does the spend-cap shape match how you think about cost control, or do you manage that somewhere else entirely? Is the approval gate useful if it's email-only and single-approver, or does that make it a toy? What flag would stop you from wiring this into an agent you actually run? Not fishing for encouragement — if this is solving the wrong problem, or solving it the wrong way, I'd rather know now.

Most AI short-form video demos skip the boring part. They show a finished TikTok, Reel, or YouTube Short. Maybe they show the prompt. Maybe they show the generated script or the final render. But the hard part is not making one video. The hard part is making the fifteenth video without the whole system turning into a pile of one-off scripts, half-remembered FFmpeg commands, broken captions, inconsistent hooks, and manual upload steps. That is where I think the conversation around AI video automation gets more interesting. Not: Can an AI generate a Short? But: What workflow does an AI agent need to generate Shorts repeatedly? I was looking at a Terminal Skills use case for building an AI short video generator, and the useful part is not the fantasy of "push one button, print infinite content." The useful part is the stack. The real job is a pipeline A short-form video generator sounds like one tool. In practice, it is a pipeline: topic research -> script -> voiceover -> footage or visual generation -> subtitles -> assembly -> platform formatting -> upload -> analytics Each step has different failure modes. Topic research can produce generic ideas. Scripts can be too long. Voice can drift from the brand. Footage can mismatch the narration. Subtitles can land under platform UI. FFmpeg can export a technically valid file that a platform still hates. Uploads can succeed in the API but fail the actual publishing workflow. If you try to solve all of that with one giant prompt, the agent has to keep too much operational knowledge in its head. That is fragile. The better pattern is to split the workflow into skills. What a skill gives the agent A skill is not just a code snippet. For this kind of workflow, a useful skill tells the agent: when to use this capability what inputs are expected what output should exist afterward what validation is required when to stop instead of pretending success That last point matters. For media automation, "the command ran" is not enough. Th

Geoff Keighley’s annual June celebration of games is here. Summer Game Fest Live, the big live show that will feature a whole bunch of gaming news and announcements, begins at 5PM ET and is set to run for two hours. The event itself will take place in person at the Dolby Theatre in Los Angeles, […]

Applications for Startup Battlefield 200 officially close on June 8, 11:59 p.m. PT. Don't wait any longer. Secure your shot at competing on the Disrupt Stage at TechCrunch Disrupt 2026 this October at San Francisco's Moscone West.

OpenAI has announced more robust security features for the small set of users who might need them.

The companies announced the deal on Friday, just one week ahead of SpaceX's historic IPO.

SpaceX won’t get easy access to billions of dollars from passive investors.

A practical reflection on why coding agents lose the thread between sessions, and why the repository itself is the right place to preserve it. I used to think the problem was memory. That was the obvious diagnosis. Every new coding-agent session started with the same ritual. Open the repository. Read the README. Inspect the project structure. Search for the files that looked important. Reconstruct the task. Guess which commands mattered. Ask again what had already been tried. Then do the actual work. Sometimes. Because a lot of the work was not work. It was orientation. A coding agent can have a large context window and still lose the operational thread. It can have chat history and still fail to know what happened in the last run. It can retrieve semantically similar notes from a vector store and still miss the one fact that mattered: this command already failed. the previous session stopped here. this file looked relevant, but it was a dead end. the validation was not actually run. One day I stopped thinking about the problem as "agent memory". That word was too broad. Too attractive. Too dangerous. Because once you say memory, the temptation is to build a bigger one. A bigger context window. A bigger note store. A bigger vector database. A bigger archive of everything the agent has ever seen, said, touched, generated, or vaguely implied. That sounds powerful, but it is also how you build a very expensive junk drawer. Context is not continuity Context is what the agent has available now. Continuity is what lets the next execution continue from what actually happened before. Those are not the same thing. Long context helps while a session is alive. It gives the model more text to work with. More files. More prior messages. More implementation details. More room. Although it is really useful it does not automatically produce continuity. When the session ends, gets compacted, moves to another tool, switches from one coding agent to another, or simply starts tomorrow