Your agent can’t use context it can’t find.StashBase is an open-source, local-first app for turning notes, research libraries, and project docs into a Wiki your agents can use.It helps you turn messy local folders into reusable agent context by creating linked Markdown Wiki Pages and making sources searchable by meaning as well as keyword.Key features:• Linked Wiki Pages – agents can create overviews and focused pages that link back to the original files• Search across difficult formats – extracts text from PDFs, DOCX files, images, and recordings for meaning and keyword search• Agent connections – use the included OpenQuill, bring Claude Code or Codex into Chat, or connect an external MCP client• Files stay under your control – source files keep their layout and Wiki Pages remain ordinary Markdown files you own• Inspectable workspace – browse, read, and edit supported files beside the conversation, then review tool calls and file editsIt’s open-source (Apache License 2.0 license).🔗 GitHub: https://lnkd.in/dUwA8wiS

This solves the memory problem for AI agents.It's called OpenViking, an open-source context database that gives agents one place to store knowledge, user memories, and reusable experience.The trick is how it organizes things. Everything is a virtual filesystem the agent can browse and search with commands it already knows: ls, tree, read.And it doesn't dump everything into context. It stores summaries first, so the agent decides which files are worth opening in full before it reads them.The results:→ Memory accuracy: 80–83%→ Input tokens: down 34.3% to 91%So the agent remembers more and reads less.Link: https://lnkd.in/eESv6Efn100% open source.

A C++ inference runtime built around the constraints robot models actually have => batch-1 latency, closed-loop control, heterogeneous hardware, and model-specific sensor and action heads. It maps VLA and world-action models into a shared stack of adapters, sequence builders, backbone execution, head plugins, and deployment adapters, with GGUF conversion and ZeroMQ or Protobuf serving. In the repo’s current matched-boundary measurements, Xiaomi-Robotics-0 BF16 inference latency falls from the Python-normalized 1.00 baseline to 0.37. GitHub Repo: https://lnkd.in/djEyrsPr

Scraping data for an AI agent shouldn’t start with a pile of glue code. PyScrappy is a Python web-scraping toolkit and optional MCP server for builders who need web data in agent workflows. It helps you turn URLs into structured, LLM-ready data by extracting page content, then exporting results as Markdown, JSON, or DataFrames for the next step in your workflow. Key features: • Generic extraction – pulls text, links, images, tables, and metadata from a URL • MCP server – exposes scrapers as tools an AI agent can call • Flexible selectors – use CSS selectors or navigate HTML with CSS/XPath helpers • JavaScript rendering – optional Playwright support handles JavaScript-heavy pages • Adaptive selectors – can relocate remembered elements when a site’s markup changes It’s open-source (MIT license). 🔗 GitHub: https://lnkd.in/dSWD2i25

gnani.ai is making a very specific bet on what India actually needs from the AI race. The Bengaluru-based company has launched Gnani Artha, a sovereign AI stack built around Evon v3.3 — a 30-billion-parameter open-weights model trained natively across 11 Indian languages. Unlike an AI service that requires an enterprise to send its data to an external provider, the stack can be deployed inside an organisation’s own data centre or private cloud. For banks, insurers, government institutions and other businesses handling sensitive information, that difference can matter almost as much as how intelligent the model itself is. Because India’s AI problem is not simply that it does not have enough chatbots. Most frontier models were built primarily around English and global internet data, while Indian enterprises operate across Hindi, Tamil, Telugu, Bengali, Marathi and several other languages — often with customers switching between them in the same conversation. Processing those languages can also require more tokens, which means more compute and ultimately more money. Gnani.ai has therefore rebuilt part of the model architecture around Indian scripts, arguing that its tokenizer can reduce the number of tokens required for Indian-language text. In other words, the company is trying to compete not only on intelligence, but on the cost of delivering that intelligence at Indian scale. The performance claims are ambitious too. Gnani.ai says Evon v3.3 has outperformed a much larger 105B-parameter Indic model across 10 of 11 languages on the MILU benchmark and matched the performance of a similarly sized hosted global frontier model. Benchmark results never settle which model is “better” for every real-world use case, and some of these comparisons come from the company’s own testing. But the more important signal is architectural: India’s AI opportunity may not require building the world’s largest model. That is what makes sovereign AI commercially interesting rather than merely nationalistic. Sovereignty only matters if the product is actually competitive on accuracy, cost and usability. India will continue using global models where they are better, just as global companies use technology built across borders. But critical sectors also benefit when there is a credible domestic alternative that gives them control over their data, deployment and economics. The real milestone for Indian AI will not be producing another model with a large parameter count. It will be proving that technology built around India’s own constraints can become the better business decision. For daily, sharp analysis of the biggest moves in the Indian business and startup ecosystem, follow StartupFox.

𝟴 𝗵𝗼𝘂𝗿𝘀 𝗼𝗳 𝗱𝗲𝗯𝘂𝗴𝗴𝗶𝗻𝗴 → 𝟮𝟬 𝗺𝗶𝗻𝘂𝘁𝗲𝘀.Not because I became 24× smarter overnight. GenAI changed the way I work. 🤖Remember spending hours debugging an SQL query, reformatting a file, or trying to figure out why a Python/PySpark job was behaving strangely……only to discover one tiny syntax issue, an extra space, or an unexpected character? 😅Those situations haven't disappeared.But the time we spend solving them definitely has.GenAI has become part of my everyday Data Engineering toolkit, and here are a few areas where it is helping me boost productivity:🔹 SQL development & formatting across different platforms and SQL dialects🔹 Python & PySpark code generation🔹 Writing test cases — turning hours of effort into minutes🔹 Debugging failed data pipelines and identifying root causes faster🔹 Understanding existing pipelines before working on enhancements🔹 Code reviews and optimization suggestions🔹 Technical documentationAnd the list keeps growing...But there’s an important catch. ⚠️𝗚𝗲𝗻𝗔𝗜 𝗶𝘀 𝗽𝗼𝘄𝗲𝗿𝗳𝘂𝗹 𝗼𝗻𝗹𝘆 𝘄𝗵𝗲𝗻 𝘆𝗼𝘂 𝘂𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱 𝘁𝗵𝗲 𝗽𝗿𝗼𝗯𝗹𝗲𝗺 𝘆𝗼𝘂'𝗿𝗲 𝗮𝘀𝗸𝗶𝗻𝗴 𝗶𝘁 𝘁𝗼 𝘀𝗼𝗹𝘃𝗲.AI can generate a solution in seconds.But as engineers, we still need to ask:→ Is the solution correct?→ Is it scalable?→ Is it optimized?→ Will it work with the existing architecture?→ Is it production-ready?Blindly copying AI-generated code might save you 10 minutes today and cost you several hours of debugging tomorrow.For me, GenAI isn't replacing Data Engineering knowledge.It's multiplying what we can do with that knowledge. 🚀𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗞𝗻𝗼𝘄𝗹𝗲𝗱𝗴𝗲 × 𝗚𝗲𝗻𝗔𝗜 = 𝗕𝗲𝘁𝘁𝗲𝗿 𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝘃𝗶𝘁𝘆Fellow Data Engineers 👇What's ONE task where GenAI has saved you the most time?Would love to hear your use cases.

Your brand reputation is no longer shaped only by what appears in the news or on social media.It’s also shaped by how generative AI describes your organization.As more people turn to AI for information and recommendations, PR and Communications leaders need to understand a new part of the conversation:How is our brand being positioned by LLMs? What narratives are emerging? And where might the answers be incomplete or inaccurate?For me, this is what makes Meltwater’s GenAI Lens so timely. It helps teams see how their brands appear in generative AI conversations, adding an important perspective to the media and social signals they already follow.The way people search is changing. Our approach to reputation intelligence needs to evolve with it.Learn more: https://lnkd.in/gPGN4Ba6How is your team thinking about brand reputation in the age of generative AI?

One web-data engine beats stitching five tools together.fastCRW is an open-source Rust web-data engine for builders who need to turn web pages into inputs for AI systems.It helps you move web content into agent and data workflows by handling scraping, crawling, mapping, search, and extraction through one toolset.Key features:• Five web operations – scrape, crawl, map, search, and extract from the same engine• Flexible outputs – return Markdown, HTML, links, screenshots, or schema-shaped JSON from a URL• Bounded crawling – follow a site crawl and collect pages without treating the whole web as one job• Local or managed deployment – run a local Rust binary or use the managed API, depending on your setup• Agent-friendly access – use the CLI, Python SDK, Node.js SDK, or MCP server with supported AI coding toolsThe engine and MCP server are open-source (AGPL-3.0).🔗 GitHub: https://github.com/us/crw⸻♻️ Share this with your network if you found it useful or insightful.✉️ If you’re into AI, ML, agents, and building real systems, join my newsletter (it’s free): dankornas.substack.com

Redis LangCache: A smarter way to reduce LLM cost and latencyOne of the biggest challenges in production GenAI applications is that similar questions often trigger completely new LLM callsFor example:“Can I get a refund for my subscription?”“Is my monthly plan refundable?”“Can I cancel and get my money back?”Traditional caching may treat these as three different requests.Semantic caching is different.Redis recently introduced LangCache, a fully managed semantic caching service designed specifically for LLM applications.hashtag#What is Redis LangCache?LangCache sits between your application and the LLM.Instead of checking whether the incoming request is exactly the same, it checks whether the new request is semantically similar to something that has already been answered.If a sufficiently similar response exists:User Query → LangCache → Cached Response No new LLM generation is required.If there is no suitable match:User Query → LangCache → LLM → Response → Store in CacheRedis reports up to 90% API cost savings and up to 15× faster responses for cache hits, although real-world savings depend heavily on the application's cache-hit rate and traffic patterns.hashtag#Key Features• Semantic similarity matching — matches queries based on meaning, not exact wording• Vector-based search — embeddings are used to find similar previous requests• Fully managed — no need to build and maintain your own semantic-cache infrastructure• Embedding model flexibility — use Redis's default embedding models or bring your own• Similarity thresholds — control how closely queries must match before returning a cached response• TTL & eviction policies — prevent stale responses from staying indefinitely• Adaptive controls — optimize precision and recall• REST API + SDK support — can be integrated with applications using Python, JavaScript and other languages• LLM-provider agnostic — can sit in front of different LLM providers• Monitoring — track cache hits, latency and savings through Redis Cloudhashtag#Semantic Cache vs Traditional Cache- Traditional cacheExact Query → Exact Match → Return Response- Semantic cacheNew Query → Embedding → Similarity Search → Reuse ResponseThat's the important shift:Cache the meaning, not just the string.hashtag#Why this matters for Agentic AIAs AI agents become more complex, they can make multiple LLM calls per user request.Reducing even a portion of those calls can improve:- Cost- Latency- Scalability- Compute efficiency- User experienceBut semantic caching also needs careful design.A similarity threshold that is too low can return an incorrect answer, while a threshold that is too high reduces cache hits. TTL, tenant isolation, data freshness and monitoring therefore become important production considerations.https://lnkd.in/dT_E_zVx

Alibaba open-sourced the code reviewer it says has served tens of thousands of developers and found millions of defects internally. Open Code Review does not leave the whole review loop to an LLM: deterministic code handles file coverage, bundling, rule matching and comment positioning, while the agent handles reasoning and repository context. On its benchmark of 200 PRs across 50 open-source repos, Alibaba reports higher precision and F1 than Claude Code with the same model, using roughly 1/9 the tokens, with lower recall as the trade-off. GitHub Repo: https://lnkd.in/dhKd2W7T

Your agents need permissions — not just prompts. Agent Identity Management (AIM) is an open-source IAM layer for AI agents that adds cryptographic identity, capability authorization, and audit trails. It helps you put a permission check around agent actions by generating an Ed25519 keypair, signing each invocation, and evaluating a declared capability before execution. Key features: • Python SDK quick start – `secure()` registers an agent and `@agent.perform_action` protects a function • Fine-grained authorization – five checks evaluate capability, attribute, context, chain, and intent before privileged actions • Local-only mode – the TypeScript SDK and OpenA2A CLI use local keys, `audit.jsonl`, and YAML capability policies without a server • Multi-language SDKs – Python, Java, and TypeScript integration paths cover the repo’s stated agent-code setups • Shared audit schema – all three deployment modes use the same audit-event schema It’s open-source (Apache License 2.0). 🔗 GitHub: https://lnkd.in/dSZ3hmce

Running a company with agents usually starts as a pile of prompts. This repo gives it an org chart. OpenCompany is an open-source runtime for solo operators who want to define and launch agent-powered company setups. It helps you move from individual agents to coordinated business roles by declaring responsibilities and human sign-off points in readable `company.toml` files, then running them through a host. Key features: • Company catalog – includes setups for a marketing agency, software company, product team, research lab, and more • Role-based configuration – each company defines its agent roster, responsibilities, and points where a human is asked to decide • Human-in-the-loop design – the README makes the operator responsible for judgment calls such as strategy, approvals, and prioritization • Local demo path – Docker-based quickstart launches a selected demo and exposes a local console to watch agents work • Active-development status – the project explicitly says its APIs, CLI, harnesses, and docs may change and it is not production-ready It’s open-source (GNU GPL v3.0 license). 🔗 GitHub: https://lnkd.in/d2G6B5sA

One web-data engine beats stitching five tools together.fastCRW is an open-source Rust web-data engine for builders who need to turn web pages into inputs for AI systems.It helps you move web content into agent and data workflows by handling scraping, crawling, mapping, search, and extraction through one toolset.Key features:• Five web operations – scrape, crawl, map, search, and extract from the same engine• Flexible outputs – return Markdown, HTML, links, screenshots, or schema-shaped JSON from a URL• Bounded crawling – follow a site crawl and collect pages without treating the whole web as one job• Local or managed deployment – run a local Rust binary or use the managed API, depending on your setup• Agent-friendly access – use the CLI, Python SDK, Node.js SDK, or MCP server with supported AI coding toolsThe engine and MCP server are open-source (AGPL-3.0).🔗 GitHub: https://github.com/us/crw⸻♻️ Share this with your network if you found it useful or insightful.✉️ If you’re into AI, ML, agents, and building real systems, join my newsletter (it’s free): dankornas.substack.com

Redis LangCache: A smarter way to reduce LLM cost and latencyOne of the biggest challenges in production GenAI applications is that similar questions often trigger completely new LLM callsFor example:“Can I get a refund for my subscription?”“Is my monthly plan refundable?”“Can I cancel and get my money back?”Traditional caching may treat these as three different requests.Semantic caching is different.Redis recently introduced LangCache, a fully managed semantic caching service designed specifically for LLM applications.#What is Redis LangCache?LangCache sits between your application and the LLM.Instead of checking whether the incoming request is exactly the same, it checks whether the new request is semantically similar to something that has already been answered.If a sufficiently similar response exists:User Query → LangCache → Cached Response No new LLM generation is required.If there is no suitable match:User Query → LangCache → LLM → Response → Store in CacheRedis reports up to 90% API cost savings and up to 15× faster responses for cache hits, although real-world savings depend heavily on the application's cache-hit rate and traffic patterns.#Key Features• Semantic similarity matching — matches queries based on meaning, not exact wording• Vector-based search — embeddings are used to find similar previous requests• Fully managed — no need to build and maintain your own semantic-cache infrastructure• Embedding model flexibility — use Redis's default embedding models or bring your own• Similarity thresholds — control how closely queries must match before returning a cached response• TTL & eviction policies — prevent stale responses from staying indefinitely• Adaptive controls — optimize precision and recall• REST API + SDK support — can be integrated with applications using Python, JavaScript and other languages• LLM-provider agnostic — can sit in front of different LLM providers• Monitoring — track cache hits, latency and savings through Redis Cloud#Semantic Cache vs Traditional Cache- Traditional cacheExact Query → Exact Match → Return Response- Semantic cacheNew Query → Embedding → Similarity Search → Reuse ResponseThat's the important shift:Cache the meaning, not just the string.#Why this matters for Agentic AIAs AI agents become more complex, they can make multiple LLM calls per user request.Reducing even a portion of those calls can improve:- Cost- Latency- Scalability- Compute efficiency- User experienceBut semantic caching also needs careful design.A similarity threshold that is too low can return an incorrect answer, while a threshold that is too high reduces cache hits. TTL, tenant isolation, data freshness and monitoring therefore become important production considerations.https://lnkd.in/dT_E_zVx

Alibaba open-sourced the code reviewer it says has served tens of thousands of developers and found millions of defects internally. Open Code Review does not leave the whole review loop to an LLM: deterministic code handles file coverage, bundling, rule matching and comment positioning, while the agent handles reasoning and repository context. On its benchmark of 200 PRs across 50 open-source repos, Alibaba reports higher precision and F1 than Claude Code with the same model, using roughly 1/9 the tokens, with lower recall as the trade-off. GitHub Repo: https://lnkd.in/dhKd2W7T

Web research gets unreliable when your agent can’t show where an answer came from. Web Search Plus is a Hermes plugin for builders who want web search and page reading with source links. It helps you research current topics from real pages by routing search and extraction through configured providers, then returning original links and clean page content. Key features: • Two Hermes tools – adds web_search_plus for source discovery and web_extract_plus for reading existing URLs • Multi-provider setup – supports search and extraction providers while working with just one configured provider • Provider fallback – can try another service when one is unavailable or returns nothing • Clean page reading – turns pages you already have into clean text for an agent • Optional local choices – SearXNG, Keenable, and the separately installed DonSeTch provider can reduce dependence on paid APIs It’s open-source (MIT license). 🔗 GitHub: https://lnkd.in/dWGm2fXg

A 671-billion-parameter AI model does not necessarily use 671 billion parameters to generate your next token. That sounds ridiculous until you understand Mixture of Experts. Imagine a normal dense Transformer. Every token enters a layer and goes through the same set of parameters. Whether the token is Python, mitochondria, or bonjour, the same feed-forward network does the work. Now make one change. Instead of one feed-forward network, put many of them inside the layer. Then add a tiny router whose job is to look at the current token representation and decide which few should handle it. Those networks are the "experts." The name makes them sound like someone manually created a coding expert, a French expert, a mathematics expert, etc. That isn't generally how it works. They are learned subnetworks, and whatever specialization emerges is learned during training. This gives you a strange machine. The model can contain an enormous number of parameters, while only activating a fraction of them for each token. DeepSeek-V3 is the cleanest example => 671B total parameters, about 37B activated for each token. So when it generates one token, hundreds of billions of parameters can effectively sit that computation out. That is the trick behind sparse MoE => increase the model's parameter capacity without paying the compute cost of running every parameter for every token. But there is a catch that gets missed constantly. Inactive does not mean nonexistent. Those weights still have to be stored somewhere. On large deployments they are spread across accelerators, and now the router has to send tokens to the right experts. Some experts can receive more traffic than others. Moving those token representations between devices creates communication overhead. Keeping expert utilization balanced becomes an engineering problem of its own. So a 671B MoE is not secretly a 37B model. It is a 671B model that has learned to choose which parts of itself are worth waking up for each token. And once you understand that, some of the strangest parameter counts in modern AI suddenly make a lot more sense.

You tell one of five coding agents running in five terminal tabs to fix something, then guess whether it's queued or already replied. CCCC runs Claude Code, Codex, Cursor and a dozen more as one group on a single append-only ledger. Delivered, read and reply are recorded as separate facts. Pause or check the group from your phone over Telegram. 1.1k stars, Apache-2.0.#AIAgents #MultiAgentSystems #AIEngineering #CodingAgents

1w𝟯𝟭𝟱,𝟬𝟬𝟬 𝗵𝘂𝗺𝗮𝗻 𝗿𝗮𝘁𝗶𝗻𝗴𝘀 𝗼𝗳 𝗧𝗧𝗦 𝗺𝗼𝗱𝗲𝗹𝘀, 𝗳𝗿𝗲𝗲 𝘁𝗼 𝗱𝗼𝘄𝗻𝗹𝗼𝗮𝗱. Datapoint AI just opened the largest human audio preference dataset I've seen, built specifically around customer support. Not WER. Not MOS. Real people choosing which voice they'd rather hear on a support call. ━━━━━━━━━━━━━━━ 𝗪𝗵𝗮𝘁 𝗺𝗮𝗸𝗲𝘀 𝗶𝘁 𝘂𝘀𝗲𝗳𝘂𝗹 → 300K+ annotations from real annotators → 15 TTS models ranked head to head → 8 categories: IVR menus, empathy, escalations, refunds and more That category split is the part people will scroll past, and it matters most. An IVR menu voice and an escalation voice are different jobs. One needs to be legible at speed. The other needs to sound like it is not enjoying your complaint. A single quality score averages those into mush. If you build support agents, you have been guessing at this. Now there is data. ━━━━━━━━━━━━━━━ 𝗧𝗵𝗲 𝗮𝘅𝗶𝘀 𝘁𝗵𝗲 𝗰𝗵𝗮𝗿𝘁 𝗰𝗮𝗻𝗻𝗼𝘁 𝘀𝗵𝗼𝘄 The quality-cost frontier plots price in dollars per 1M characters. Every model on that axis is a rental. Per-character billing is the only cost model it can express. A model running on your own GPU has no per-character price at all. Its cost is hardware and electricity, and it drops toward zero as volume climbs. It cannot be plotted on that x-axis, so it mostly is not there. That is not a knock on the benchmark. It is a reminder that a leaderboard built on API pricing will always frame self-hosting as missing rather than as a different shape. ━━━━━━━━━━━━━━━ 𝗧𝗵𝗲 𝗿𝗲𝗮𝗹 𝗮𝘀𝘀𝗲𝘁 𝗶𝘀 𝘁𝗵𝗲 𝗱𝗮𝘁𝗮𝘀𝗲𝘁, 𝗻𝗼𝘁 𝘁𝗵𝗲 𝗿𝗮𝗻𝗸𝗶𝗻𝗴 The leaderboard tells you what 15 vendors scored last month. It is stale the moment someone ships a new checkpoint. 315K human preference pairs are something else entirely. → Re-rank on the categories your business actually runs → Train a reward model for automated TTS evaluation → Use it as preference data to align an open-weight model you own A scoreboard is a snapshot. Preference data is leverage. ━━━━━━━━━━━━━━━ Rankings and pricing above are Datapoint's own published numbers. I have not reproduced them. Neither has anyone else reposting the chart today. I build enterprise voice agents that run on customer infrastructure — TTS, telephony, escalation logic, no audio leaving the building.

Loop vs Graph Engineering: Clearly Explained! A loop is an autonomous cycle where an agent plans, acts, verifies the result, and keeps iterating until it reaches a stopping condition. The basic pattern is simple: Plan → Act → Verify → Repeat Loop engineering is about making that cycle reliable. You decide what context survives between iterations, how the agent evaluates its own work, when it should retry, how failures are handled, and what condition finally ends the run. This works well when one agent can own a coherent task from start to finish. The problem starts when the work itself becomes more structured. Some tasks need to happen in parallel. Different agents may need different context, tools, memory, or permissions. Certain steps may require human approval, while others can continue automatically. At that point, trying to force everything through one loop makes the system harder to reason about. That is where graph engineering becomes useful. A graph makes the workflow explicit. Nodes represent units of work such as agents, tools, validators, or deterministic functions, while edges define how state and control move between them. The important part is that loops and graphs are not competing architectures. A loop can itself be one node inside a larger graph. For example, a research agent may run its own Plan → Act → Verify loop, while a separate analysis agent runs another loop. A graph can then coordinate when those agents start, what context they receive, how their outputs are combined, and what happens next. So the practical distinction is: • Loop Engineering: design one autonomous execution cycle around a task • Graph Engineering: design how multiple execution cycles, tools, and decision points coordinate through shared state and explicit control flow You usually start with a loop when one agent can handle the task end to end. You move to a graph when the work needs parallel execution, specialized agents, different permissions, explicit branching, or clearer control over how state moves through the system. Graph engineering does not replace loop engineering. It becomes useful when one loop is no longer enough to hold the workflow together. I've shared the full article and Hands-On AI Engineering repo in the comments!