Daily AI Wire News’ Post

We've released an update to our Python library so that it now supports realtime publishing and, in particular, message publishing via a stream of append operations, which is what you need to be able to support streamed LLM responses with Ably's AI Transport. Read more on the Ably blog: https://lnkd.in/e59eWfVc

🐍 Python in 2026: It’s Not Just a Language Anymore — It’s the Runtime of AI The conversation has shifted. Python isn’t just used for AI — it’s the infrastructure on which AI operates. Here’s what the modern Python + AI stack actually looks like: 🤖 Agentic Frameworks Tools like LangChain, LlamaIndex, AutoGen, and CrewAI are all Python-first. Multi-agent orchestration — where LLMs plan, delegate, and execute tasks autonomously — is being built almost exclusively in Python. 🔧 Tool Use & Function Calling Python makes it trivial to wrap any function as a tool for an LLM. Define a function → pass its schema → your agent calls it. The Anthropic SDK, OpenAI SDK, and Gemini API all have Python as their primary interface. 🧠 RAG Pipelines Retrieval-Augmented Generation stacks — FAISS, Chroma, Pinecone + LangChain/LlamaIndex — are Python through and through. Building a production RAG pipeline in any other language feels like swimming upstream. ⚡ Async-first Agent Modern agents run async. Python’s asyncio + httpx + streaming APIs make it possible to build responsive, real-time agent pipelines that stream tokens, handle tool calls, and manage memory — all concurrently. 📦 MCP (Model Context Protocol) The emerging standard for connecting AI models to external tools and data sources? Python SDKs are leading adoption here too. The engineer who understands Python and how LLMs reason is the most valuable person in the room right now. Not because Python is magic — but because the entire agentic AI ecosystem was built on top of it. Camerin - Indian Institute Of Upskill Camerin Innovate PVT LTD

OpenAI is acquiring Astral — the team behind uv, Ruff, and ty. If you write Python, you've almost certainly used their tools. And this acquisition is a big deal. A quick recap of what Astral built: uv — blazing fast package & environment manager (replaces pip, venv, pyenv, pipx — all in one) Ruff — linter + formatter written in Rust, 10-100x faster than traditional Python tools ty — a type checker that's still early but already promising In just ~2 years, these tools went from zero to hundreds of millions of downloads per month. That's an insane growth trajectory for developer tooling. Why did OpenAI buy them? Codex — OpenAI's AI coding assistant — has crossed 2M weekly active users with 3x growth and 5x usage increase since the start of 2026. OpenAI's vision is to move Codex beyond just generating code, toward an AI that participates in the entire dev workflow: planning, running tools, verifying results, maintaining software. Astral's toolchain sits right in the middle of that workflow. Integrating it makes Codex deeply native to how Python developers actually work. The question everyone's asking: will the tools stay open source? Both OpenAI and Astral say yes. The tools will remain open source and community-supported post-acquisition. And since all three are MIT-licensed on GitHub, the community can always fork if things go south. Worth noting — Anthropic also acquired Bun (the JS runtime) back in December. The AI labs are clearly racing to own the developer infrastructure layer, not just the models. Exciting times for Python developers. Slightly unsettling times for open source independence.

Show HN: SynapseKit – Async-native Python framework for LLM pipelines and agents I just came across SynapseKit, a promising async-native Python framework designed for building scalable LLM pipelines and intelligent agents. Here are a few concrete takeaways and why it caught my eye: What it solves - Simplifies orchestration of LLM prompts, chat workflows, and agent actions in a single, coherent framework. - Focuses on async-first design, which can unlock better throughput and responsiveness in production-grade AI apps. - Encourages clean separation of concerns: prompt templates, orchestration logic, and evaluation hooks. Key strengths - Python-native experience with strong concurrency support, reducing the "glue code" overhead when wiring together prompts, memory, and tools. - Built-in patterns for retry, timeout, and error handling, which are essential for reliable AI systems. - Extensible architecture that seems friendly to both researchers prototyping and engineers shipping features. What to consider - As with any new framework, evaluate how it fits your existing stack, dev workflows, and deployment strategy. - Check compatibility with your preferred LLM providers, toolkits, and observability stack. - Review community activity, documentation quality, and roadmap alignment with your use cases. Who should check it out - Teams building AI copilots, chat agents, or automation pipelines that need scalable orchestration. - Python shops looking to standardize async workflows around LLMs without sacrificing performance. If you’re exploring scalable LLM infrastructure or looking to streamline agent-based workflows, SynapseKit is worth a closer look. I’ll be watching how the project evolves and how it compares to other orchestration layers in this space. Link: https://ift.tt/edpB29m Hashtags: #AI #LLM #Python #AsyncProgramming #SoftwareEngineering #MLOps #AIEngineering #LLMPipelines #TechNews #ShowHN. Read my thoughts: https://ift.tt/zkOm4rd

🚀 New Release: NTQR Open Source Python Package I’m excited to share the latest release of NTQR, a Python package designed for those working at the intersection of AI safety, scalable oversight, and formal verification. NTQR provides a formal framework for reasoning about systems where ground truth is unknown—an increasingly relevant constraint when supervising or composing advanced AI systems. If you’re thinking about verifier reliability, adversarial reporting, or Gödel/Löb-style limits in oversight architectures, this package is built with you in mind. 🔍 What’s new Improved classes for constructing sample statistics variables and their axioms. Executable Jupyter notebooks that demonstrate the logic and its algebra. Clearer abstractions for computing possible and consistent evaluation sets. 📦 Get started in minutes pip install ntqr cd <your-working-directory> ntqr-docs cd ntqr_notebooks jupyter notebook This will install the package and generate a local set of executable notebooks that: Introduce the algebra behind the counting logic Demonstrate key constructions Demonstrate no-knowledge alarms for misaligned classifiers 💡 Why this matters As AI systems become more capable, oversight itself must scale—often through other AI systems. But this introduces a core problem: what happens when the systems we rely on for verification are not fully trustworthy or we do not know the ground truth? When AI judges monitor other AIs they are often acting as classifiers. Who judges the judges? NTQR helps you make them monitor themselves. NTQR offers a way to: Treat unsupervised evaluation as a logical problem. Infer group evaluations that match the observed agreement and disagreement counts between classifiers, the logically consistent evaluations. Construct no-knowledge alarms for misaligned classifiers using only the counts of how they agree and disagree on a test. If you’re exploring alignment, verification, or theoretical limits of monitoring systems, I’d be very interested in your feedback. 📚 Docs: https://lnkd.in/eugreNDd #AISafety #ScalableOversight #Alignment #FormalMethods #MachineLearning #Jupyter #Python

Rust-based AI frameworks use 5x less memory than their Python equivalents. That's from the 2026 AI Agent Benchmark. And the trend keeps accelerating. 𝗧𝗵𝗲 𝗽𝗮𝘁𝘁𝗲𝗿𝗻 The most impactful Python tools in AI are already written in Rust under the hood: 👉🏽 Hugging Face Tokenizers: Rust core, Python bindings 👉🏽 Polars: Rust core, Python API 👉🏽 Ruff: Rust linter, 10-100x faster than Flake8 👉🏽 Pydantic Monty: Rust interpreter for safe LLM code execution 👉🏽 uv: Rust package manager, replaced pip for most of us The playbook is the same every time. Write the performance-critical parts in Rust, expose a Python API with PyO3. Users get Python ergonomics with Rust performance. 𝗪𝗵𝘆 𝘁𝗵𝗶𝘀 𝗺𝗮𝘁𝘁𝗲𝗿𝘀 𝗳𝗼𝗿 𝗔𝗜 AI agents run lots of tools, process lots of data, and keep lots of state. Memory matters. Latency matters. When you're spinning up hundreds of agent instances, 5x memory savings is the difference between one server and five. xAI fully transitioned their AI infrastructure to Rust. That's a strong signal from a company running models at massive scale. 𝗧𝗵𝗲 𝗼𝗽𝗽𝗼𝗿𝘁𝘂𝗻𝗶𝘁𝘆 If you know both Python and Rust, you're in a rare position. Most AI engineers only know Python. Most Rust developers don't work in AI. The intersection is small and getting more valuable. You don't need to rewrite everything in Rust. Just the hot paths. 𝘋𝘰 𝘺𝘰𝘶 𝘶𝘴𝘦 𝘢𝘯𝘺 𝘙𝘶𝘴𝘵-𝘣𝘢𝘤𝘬𝘦𝘥 𝘗𝘺𝘵𝘩𝘰𝘯 𝘵𝘰𝘰𝘭𝘴?

🔮 Gemma 4 model family enables local, privacy-focused tool-calling agents. Learn how to build a system using Python and Ollama for dynamic interactions with external functions. #AI #Tech #DevOps

Posit's AI ecosystem has grown a lot. That's exciting for R and Python developers, but it can also make the starting point less obvious. Which package should you begin with? What is the foundation layer? What should you use for chat in Shiny, querying data in plain English, or building workflows grounded in your own documents? Vedha Viyash wrote this post to make that easier. It walks through what each package in the stack does, how the pieces fit together, and which path makes the most sense depending on what you want to build. The guide should help you spend less time sorting through the ecosystem and more time building with it. 📚 Read it here: https://lnkd.in/d8D3ZfiD #RStats #Python #Posit #AI #DataScience #Shiny #Appsilon

Python/MLX engineer wanted Hey, if you are into inference-level ML work and want to do something genuinely novel rather than another RAG pipeline or chatbot wrapper, read on. Small Welsh company working on a formally grounded AI governance architecture, with a UK national patent on the core invention and a published mathematical foundation on arXiv. What the project is about Most AI governance operates at the edges, checking inputs and outputs while leaving the model's internal reasoning untouched. The architecture is retrieval-grounded: rather than letting the model reason freely from parametric memory, every inference is anchored to a specific retrieved evidence base. The research question is how to enforce that grounding natively inside the model rather than just wrapping around it. The work involves targeted intervention at the attention layer, steering the model's reasoning toward retrieved evidence and detecting when it drifts away from it. This is not fine-tuning or LoRA. It is architectural, getting inside the forward pass and modifying how the model attends to information during inference. The implementation language is Python throughout. MLX is the primary framework for inference and intervention work; familiarity with it is a genuine advantage, though strong Python and a solid understanding of transformer attention mechanics matter more. What you would be doing Working directly with the founder to translate formal governance specifications into working MLX implementation. The work is research implementation rather than production engineering; you will be reading model internals, understanding how attention weights are computed, and figuring out how to hook governance logic into the forward pass cleanly and efficiently. The details The project runs August to January 2027, six months. Fully remote, although Welsh-based, Cardiff or Swansea is an advantage. Invoicing as a subcontractor at a competitive day rate commensurate with research-level implementation work. What we are looking for The most important thing is that you find this kind of work interesting. Strong Python, solid understanding of transformer attention mechanics, and comfort reading and modifying model source code. Experience with MLX, inference optimisation, or anything involving attention head manipulation or custom forward pass logic is a significant bonus. Being UK-based is a must. No formal application process -- just drop a message with a bit about your background and what you have worked on and we can have a conversation.

Shipped: Python SDK for tag-graph agent memory. For a year I've been chasing one problem — how do you give an LLM agent memory that's bounded, predictable, and doesn't blow your token bill? Vector DBs → fuzzy, impossible to budget. Raw history → 5-turn context overflow. Summarize-and-re-inject → silently drops facts the agent needs three turns later. So we built MME — a bounded tag-graph memory engine. Every memory carries tags, retrieval starts from the current scope, propagates to neighbors with bounded fanout, ranks by graph proximity. Deterministic, token-budgeted, sub-50ms at 100k items. Today the Python SDK is live: → pip install railtech-mme → Native LangChain + LangGraph tool integrations → Online learning via feedback loops → Open source Wrote up the full design rationale, tradeoffs vs. vector search, and the SDK surface area here: https://lnkd.in/eNR5n_iq Honest beat — this is launch day. If you're building LLM agents in Python and "my agent doesn't remember things well" feels familiar, I'd love to hear what's clunky about the API. #AI #Python #LangChain #LLM #AgentMemory #BuildInPublic #OpenSource