标签：#ai

A few weeks back I had an agent reconciling a vendor list. It ran clean. No error, no crash, output...

India's largest food delivery platform processes over 1.5 million orders every single day. One missed...

I Read Your AI Agent Logs So You Don't Have To: A $149 Service That Beats Another Dashboard What if the cheapest fix for your broken AI agent is a stranger reading 40 hours of traces for $149? I spent the last month doing exactly that — reading roughly 40 hours of production logs from teams running LangGraph, CrewAI, and AutoGen agents for paying customers. Not building observability dashboards. Not comparing LangSmith vs Langfuse. Reading the actual traces and writing up what was wrong, what to fix, and in what order. Three observations from those 40 hours: The dashboard was never the problem. Every team already had LangSmith or Helicone or a homegrown equivalent logging every LLM call. None of them were reading the logs. The "fix" was almost always one of seven patterns. I kept seeing the same shapes — stuck retry loops, idempotency gaps, tool-call argument drift, etc. — dressed up in different framework jargon. The teams that asked for "another tool" were the ones least likely to use it. They had 14 tools. The teams that paid for an hour of my time were the ones who said "I don't have time to look at this myself." That second group is who I'm now building a $149 service for. Here's why I think it works, what the deliverable looks like, and where the limits are. Why a $149 fixed-fee reading and not an hourly rate I tested three pricing models against the same deliverable: a written diagnostic of an agent's last 7 days of traces, prioritized fixes with code-level examples, and a 30-minute async follow-up. Model Conversion Avg revenue / inquiry Notes $200/hr (estimated 3hr) 2/40 inquiries $15 (lost 38 to sticker shock) Freelance default, fails on cold traffic $1,500 flat project 0/40 inquiries $0 Above the "I'll just keep it broken" threshold for most small teams $149 fixed diagnostic 11/40 inquiries $41 Below "another contractor" threshold, above "free advice" The $149 number is the inversion point — low enough that a stressed eng lead can expense it without a meet

You have explained your tech stack to your coding agent four times this month. You mentioned your preferred approach to a problem in January, and your agent has no idea it ever happened. You corrected a decision last week and the old version is still surfacing. You set up context at the start of every session because there is nowhere for it to go at the end. This is not a model problem, as GPT-4, Claude, and Gemini all have the same limitations. The model is stateless. They all have inbuilt memory, and still every session starts from zero unless you have the infrastructure to persist what matters and surface it at the right moment. That sophisticated memory infrastructure is what most developers do not have. VEKTOR Slipstream v1.6.3 is a local-first memory SDK for AI agents. This release adds the layer most memory systems skip: not just storing what you tell it, but managing what should still be there months later: curation. What you actually get Before the architecture: What changes for you as a developer embedding this SDK. Every AI memory system forces decisions you didn’t realise you were making. Where does your agent’s context actually lives, is it on your machine or on someone else’s server? Are you paying per token every time your agent understands a memory, or does that happen locally? When you connect your GitHub, your calendar, your files — where does all that data go, and who can see it? Most memory systems answer all four questions for you, quietly, in their terms of service. VEKTOR’s answer to all four is the same: your machine, your data, your rules. Memory lives in a single SQLite file you own. Embeddings run locally on CPU — no API calls, no per-token cost, no data leaving the process. MCP connectors spawn as local stdio processes; nothing is routed through an external service. There is no telemetry, no cloud sync, no account required. If you want to understand exactly what your agent knows about you, you open the database with any SQLite browser and

Anyone who works with Ruby on Rails knows that, despite the framework being incredible for productivity, there are some classic workflow deficiencies that haunt almost every project. You are focused on writing code, but suddenly you need to open an external tool like Postman to test a route. Then, you run a complex script to generate a static database diagram. And at the end of the day, you still need to manually update the API documentation, which will inevitably become outdated in the next sprint. This constant context switching and manual maintenance generates enormous friction. To cover these deficiencies, I developed three gems that bring these tools inside your application. They are so practical that they quickly become indispensable in any Rails project. Meet each one of them: 1. rails-api-docs : The End of Outdated Documentation The deficiency: API documentation always starts with good intentions, but as the system evolves—new routes, parameters, and response fields—it quickly stops representing reality. Keeping this updated manually is repetitive and frustrating work. The solution: The rails-api-docs gem solves this by leveraging what Rails already knows. It inspects your routes, controllers (via AST analysis using Prism), and the ActiveRecord schema to automatically generate the first draft of your documentation. Everything is saved in a single YAML file ( config/rails-api-docs.yml ), which serves as the single source of truth. Why it is indispensable: Append-only strategy: When adding new routes and running the generator, the gem only appends what's new. Your descriptions, custom examples, and tags are never modified or deleted, making the documentation a living document. Zero development friction: You edit the YAML in one window and view the updated documentation in the browser at localhost:3000/rails/api-docs instantly, with no build step required. For production, it exports a single static HTML file without any external dependencies. 2. rails-http-lab

LLM Cost Attribution with OTel, Next.js for AI Agents, LLM Security Testing Today's Highlights This week, we delve into practical strategies for managing LLM costs in production using OpenTelemetry and explore Next.js 16.2's new tooling for building AI agent frontends. We also examine an experiment on LLMs' ability to exploit application vulnerabilities, emphasizing security in applied AI. Per-project LLM cost attribution with OTel spans: the wiring (Dev.to Top) Source: https://dev.to/jasmine_park_dev/per-project-llm-cost-attribution-with-otel-spans-the-wiring-3897 This article details a practical approach to attributing Large Language Model (LLM) costs to specific teams or projects within an organization. Facing a common problem of LLM bills appearing as a single line item, the author describes how to implement granular cost tracking using OpenTelemetry (OTel) spans. The core idea involves instrumenting the LLM gateway to tag every request span with relevant metadata like team.id and llm.model_name . This allows for detailed reporting and chargebacks, enabling organizations to understand and manage their LLM expenditure effectively. The implementation focuses on "the wiring" behind this system, leveraging OTel for observability. By attaching custom attributes to spans, teams can aggregate usage data by project, department, or even specific application features. This moves beyond opaque cloud invoices to actionable insights, a crucial step for companies scaling their AI adoption and seeking to optimize resource allocation and financial accountability for generative AI services. The article provides a blueprint for integrating this mechanism into existing LLM infrastructure. Comment: Setting up OTel spans for LLM cost attribution is a game-changer for production environments, finally giving us visibility into who's spending what on which models. This technique is essential for scaling LLM applications sustainably. Next.js 16.2: Deeper Tooling for AI Agents (InfoQ) So

NousResearch Agent, Open-Source Notebook LM, & Local Multimodal OCR for Consumer GPUs Today's Highlights Today's highlights feature new open-source tools empowering local AI inference and deployment, including an adaptive agent from NousResearch, a self-hostable AI-powered notebook, and a lightweight multimodal OCR solution. These practical GitHub trending projects enable developers to build and run advanced AI applications directly on consumer hardware. NousResearch Unveils Hermes Agent for Adaptive Local AI (GitHub Trending) Source: https://github.com/NousResearch/hermes-agent NousResearch, a prominent contributor to the open-weight LLM ecosystem with models like the Hermes series, has unveiled hermes-agent , a new GitHub trending project described as "The agent that grows with you." This initiative represents a significant step towards practical, adaptive AI agents designed for local execution. While specific architectural details are awaiting a deeper dive into the repository, the "grows with you" philosophy strongly implies advanced capabilities for personalized learning, continuous adaptation, and long-term memory integration—features crucial for self-hosted AI applications. Such an agent is highly relevant for developers focused on local inference, as it provides an open-source framework to build sophisticated agentic workflows, potentially integrating seamlessly with local LLM runtimes such as llama.cpp or vLLM . This allows users to leverage powerful open-weight models directly on their consumer GPUs, enhancing privacy and reducing reliance on cloud services. The project's emergence from NousResearch solidifies its potential as a robust foundation for next-generation local AI applications. Comment: A NousResearch agent is exciting; it implies strong open-source model compatibility and local deployment. I'm keen to see its learning mechanisms and integration potential with local LLM runtimes. PaddlePaddle's Lightweight OCR Toolkit Bridges Images to Local LLM

With just two weeks to go, StrictlyVC Los Angeles is quickly approaching. On Thursday, June 18, at The Aerospace Corporation Campus in El Segundo, investors, founders, and tech leaders will gather for an evening of conversation exploring some of the most consequential shifts taking place across venture capital, defense technology, artificial intelligence, and advanced industry. Secure your spot here. […]

The Framing Problem When industry analysts discuss "AI CAD," they are frequently conflating two fundamentally different computational paradigms: generative mesh synthesis and parametric feature modeling. This conflation has produced a decade of inflated expectations, underwhelming demos, and a persistent belief that real AI CAD is still "coming." It is not coming. For a specific and technically meaningful definition of AI CAD, it has arrived. Mesh Generation vs. Parametric Modeling: Why the Distinction Is Everything Contemporary generative 3D tools including neural radiance field reconstructions, diffusion-based mesh generators, and implicit surface networks produce geometry as an unstructured point cloud or polygon mesh. These representations are geometrically expressive but engineering-inert. They carry no feature history, no constraint graph, no dimensional intent. A mesh cannot be toleranced. A mesh cannot propagate a design change. A mesh cannot be submitted to a manufacturer without full reconstruction from scratch. Parametric CAD, by contrast, encodes design intent as a structured sequence of operations — extrusions, revolves, fillets, boolean operations each governed by explicit dimensional constraints and parent-child dependency relationships. The parametric model is not merely a shape; it is a design process, replayable, modifiable, and transferable across manufacturing contexts. The meaningful technical question for AI CAD in 2026 is therefore not " can AI generate a 3D shape? " that has been demonstrable since 2019. The question is: can AI generate a valid parametric feature tree from natural language input, with embedded manufacturing constraints, that survives downstream engineering use? What This Requires Architecturally Answering that question in the affirmative requires a system that can: Parse engineering intent from unstructured natural language distinguishing, for instance, between a cosmetic fillet and a stress-relief fillet, or between a cleara

Estonian government benchmark shows how dozens of models combat Russia's "strategic narratives."

Meta was previously reported to be exploring facial recognition for its smart glasses.

OpenAI has significantly improved the chatbot's "dreaming" architecture.

Musk can't be trusted to protect X user privacy, public commenters warn FTC.

Meta may have found one way to slash its massive data center bill: tents.

Poke, the startup that lets people use AI agents through simple text messages, has become the first AI agent approved for Apple’s Messages for Business platform.

Canada's "AI for All" plan prioritizes strengthening data protections and increasing AI adoption.

Fusion startup Helion is racing to complete a power plant for Microsoft by 2028. A fresh infusion of cash should help with that.

Hello, I'm Shrijith Venkatramana. I'm building git-lrc, an AI code reviewer that runs on every commit. Star Us to help devs discover the project. Do give it a try and share your feedback for improving the product. What if you could change how an AI thinks without retraining it? Not by rewriting prompts. Not by fine-tuning billions of parameters. Not by collecting another mountain of training data. Instead, imagine finding a direction inside the model's internal representation space and nudging the model a little in that direction. A small push. A different behavior. This idea sits at the heart of one of the most fascinating areas of modern AI interpretability: steering vectors . Steering vectors suggest that many behaviors we care about—careful reasoning, honesty, coding style, security awareness, verbosity, and more—may already exist inside a model. The challenge is learning how to activate them. Let's explore what steering vectors are, how they're created, and why they might become one of the most practical tools for controlling AI systems. 1. What Exactly Is a Steering Vector? Large language models process information through layers of high-dimensional activations. At any point during generation, the model's internal state can be represented as a vector containing thousands of numbers. Researchers discovered something surprising: Different behaviors often correspond to different regions of this activation space. For example: Writing Python code Solving math problems Speaking French Explaining concepts carefully Producing insecure code Each tends to produce distinctive activation patterns. A steering vector is essentially the difference between two activation patterns. Suppose we gather examples where the model is: Careful Methodical Thorough and compare them to examples where it is: Rushed Superficial Incomplete The average difference between these internal states becomes a steering vector. At inference time, we can add that vector back into the model's activatio

Kevin O'Leary agreed to halve the size of his planned 40,000-acre data center in Utah amid mounting pressure from residents and activists, as reported earlier by local affiliate ABC4. The Shark Tank star sent a letter to Utah Senate President J. Stuart Adams on Thursday, saying that he will remove 19,430 acres from the project, […]

Enlace a post en Español Click If you are developing games in Godot and using AI to help you code, you are probably tired of constantly switching tabs between your editor and the browser. Copying code, pasting it, explaining your scene context over and over again... it is a massive workflow killer. To solve this, I built Golem-AI (named after the Godot Engine logo because let's face it, it looks like a tiny, friendly mechanical golem). It is a "Cursor-style" AI assistant extension integrated directly into a dock right inside your Godot 4.2+ editor. Today, I am opening the repository to the community as a completely open-source project. It is currently in Beta and has some bugs, but it is fully functional, and I want to share it so we can improve it together. / ____/___ / /__ ____ ___ / | / _/ / / __/ __ \/ / _ \/ __ `__ \______/ /| | / / / /_/ / /_/ / / __/ / / / / /_____/ ___ |_/ / \____/\____/_/\___/_/ /_/ /_/ /_/ |_/___/ 🎮 How it Looks Inside the Editor Here is a glimpse of the integrated dock interface, its session history, and the context autocomplete system in action: 🔥 Key Features 🦙 Local & Cloud Providers: Connect it to Ollama or LM Studio for a 100% free, offline local workflow, or hook it up to OpenAI, Anthropic, Gemini, or Cursor proxies. 🧠 Cursor-Style UX & Context (@ Mentions): Type @ in the chat composer to automatically attach open scenes, specific project files, or custom skills directly into the prompt. 🛠️ Editor Tool Calling: It features an optional multi-step verification loop. The AI can actually interact with native Godot editor tools to help you iterate and fix things faster. 📚 Markdown Skills System: Feed the assistant specific workflows, style guides, or documentation using standard markdown files (/skill or @skill :id). 💬 Advanced Chat UI: Built-in "thinking blocks", agent step progress tracking, searchable history sessions, and a native bilingual UI (English / Spanish). 🛠️ The Current State: "It works, but..." (Looking for Beta Testers!) L