Don't read this if you just bought a GPU.Someone got a 2.78 trillion parameter model running on a laptop CPU. 8 GB of RAM. Zero GPUs.Now the catch, because it's a big one: 26 seconds per word.That's also the entire point. The wall was never speed, it was capacity. K3 is 1.56 TB as shipped, so no consumer machine could run it at any price. Now it runs. Slowly. On hardware you already own.How it fits:→ K3 is a mixture of experts. Only 16 of 896 experts fire per layer, so 104B params are active per token out of 2.78T. That's 3.7%→ The other 96.3% is 1.447 TB of sleeping experts that never enter RAM. They stream off the disk and get multiplied straight out of their packed 4-bit form, never unpacked→ The dense trunk streams layer by layer instead of sitting resident, which turns the memory requirement from a floor into a dialWildest part:The output is byte-identical from 8 GB to 224 GB. More RAM buys speed and nothing else.>> 8 GB: 26.5 s/token>> 32 GB: 24.2 s/token>> 64 GB: 19.8 s/token>> 128 GB+: 5.6 s/tokenSame prompt. Same answer. Only the clock moves.No CUDA. No PyTorch. No BLAS. No framework.The entire engine is a 176 KB binary. Six C files, libm and OpenMP, nothing else. It indexes 497,220 tensors across 96 shards in 0.27 seconds.A 176 KB binary running a 1.56 TB model.100% Open Source. Apache 2.0.

🎙️ New open‑weight speech‑native model that “do math out loud”Kyutai has released 'Voice of Reason', two 9B checkpoints built on GLM‑4‑Voice‑9B that take a spoken math problem and answer in speech, with no transcription step and no separate text LLM in the loop.Key points from Kyutai’s announcement and paper:- Base vs. fine‑tuned: On spoken GSM8K, the base GLM‑4‑Voice model scores 27.3%. After supervised fine‑tuning + reinforcement learning, the Voice of Reason models reach ~70.3% (direct) and ~77.1% (STITCH, with silent reasoning chunks).- Two checkpoints:glm-4-voice-of-reason-9b – answers directly, with any step‑by‑step reasoning spoken aloud.glm-4-voice-of-reason-stitch-9b – interleaves silent reasoning while speaking, so “thinking” doesn’t add extra latency.- Open weights, self‑hosted: Both models are released on Hugging Face under the GLM‑4‑Voice license and can run in BF16 on a single H100 using the GLM‑4‑Voice codebase for the speech tokenizer/decoder. No third‑party inference provider is hosting them yet.Why it matters -Shows that reasoning can be embedded directly in audio tokens, not just via cascaded ASR → text LLM → TTS pipelines. Relevant for voice agents, call‑center assistants, and hands‑free agentic workflows.This is still a research release focused on math benchmarks, not a general “voice AGI” claim but it’s a solid step toward more capable, lower‑latency speech‑native agents.#AI #VoiceAI #LLM #AgenticAI #OpenSource #MachineLearning

A chatbot grounded in retrieved content needs the right source, quickly. That’s one reason the discussion around Jev’s fast, structured decisions is interesting.Hybrid retrieval is a technique, not a product specification. You still need to agree which sources are authoritative, which business rules apply, and what users and stakeholders expect to find.People may also value behaviours from the existing search. As with software compatibility, changing those can make sense once you understand what they rely on and why.These decisions shape the answer, but also have to keep search interactive. Calling a large generative model for every classification or routing step can quickly consume the latency and cost budget.GLiNER, its open-weight derivatives and other small language models have been useful building blocks here. In weekend experiments on my gaming laptop, I explored generic adaptations: extending language support and knowledge, extracting or classifying dates and locations, and detecting personally identifiable information (PII) so it can be masked or removed.A usable dataset and fine-tuning produced useful gains over the base models within hours on the tasks tested. Performance and memory tuning, including dynamic quantization, then made them practical to run on standard CPU servers with low latency.Since March, we’ve used some of these models and derivatives at Nearform to build software that is now in production, with encouraging customer feedback.Laya, GLiClass, GLiFormer and open-weight alternatives for Jev-style decisions give us even more options to explore. Benchmarks such as typed-decisions and JevBench can help choose what to test, provided task-tuned results are kept separate from results on unfamiliar workflows.For the service itself, the useful checks are decision quality, how often a model is confidently wrong, and latency and cost under real load.Models, frameworks and evaluation links in the comments.

Karpathy's nanochat repo walks you through the full LLM training pipeline Covers the full LLM pipeline in one place. Tokenization: → BPE tokenizer training from scratch → Bits-per-byte evaluation metrics Pretraining: → Base model training with scaling laws → Single --depth dial sets transformer layers → All other hyperparameters auto-calculate Fine-tuning: → Supervised fine-tuning (SFT) → RL-based alignment → Full chat capability Inference: → CLI chat interface → KV cache optimization Evaluation: → ARC, GSM8K, MMLU, HumanEval benchmarks → DCLM CORE scoring Community speedrun leaderboard: → Challenge: time-to-GPT-2 performance → Current record: 1.65 hours → Open to new submissions Github: https://lnkd.in/d89-ezKR Repost ♻️ for AI developers.

An engineer in Kerala built something 18 months ago that the internet went crazy for last week. Last week, one demo was everywhere. A model called Jev, built to make instant decisions instead of writing paragraphs. The launch video was good, the timing was perfect, and by day two every X account on the timeline had reposted the same clip. In Kasaragod, Kerala, an engineer named Nandakishor Mukkunnoth was watching the same clip everyone else was. He wasn't impressed in the way the rest of the internet was, he recognized it. 18 month earlier, he had built almost the same thing. A non-autoregressive model, meaning it skips generating text word by word and just outputs a decision directly, with a real confidence score attached to it. He wrote the paper, put it on arXiv, released the model weights on Hugging Face, published the training dataset, and even shipped a small Python package so people could run it themselves. He posted it on Reddit too, hoping someone would notice. Almost nobody did. He had built it around sales conversations, a fairly narrow use case which sat there, technically excellent, practically invisible. Then Jev launched. Built by TypeSafe AI, a company started by Diogo Almeida, who had worked on ChatGPT's training at OpenAI. Closed model, waitlist only, no paper, no open weights. But it had a name behind it that people trusted on sight, and that alone got it a thousand times more attention than Nandakishor's work ever got. He didn't spend his energy arguing about who did it first. He posted a straight comparison instead, numbers next to numbers, and let people read it themselves. It crossed a thousand points. As he put it later, not every AI problem needs an autoregressive chatbot to solve it. Then he went back to his desk and rebuilt the whole thing from scratch. What came out was Laya, a 421 million parameter model, released fully open under a license anyone can use commercially. It answers in about 33 milliseconds on a single GPU, where Jev takes somewhere between 150 and 276. Its confidence scores are also better calibrated, meaning when it says it's 80 percent sure, it actually is right about 80 percent of the time. He didn't oversell it either. The model card for Laya says clearly that it struggles with true zero-shot tasks and works best once you fine-tune it for your specific case. There is something oddly satisfying about the whole story, a model built quietly in Kasaragod sat on the internet for 18 months. Then a similar idea launched with a big name behind it, better distribution, and suddenly the whole internet was talking about it. Again proves that, India has an insane amount of talent, sometimes the gap isn't talent or even the ability to build, It is simply visibility.

Nailed it! Jev founder Diogo Almeida (ex-OpenAI):"The next era is not the Claude Code or Codex era. Claude Code is still part of the assistance era. What’s next after RLHF is models built for software, not for the human in the loop."In this 36-minute talk, the co-creator of ChatGPT explains why models that are superhuman at chat still fail at real automation, and why that gap is baked into how they were trained.The key?RLHF optimized AI to please the person watching it. That makes great assistants and mediocre unattended systems. Visible uncertainty gets punished, confident-sounding errors get rewarded, and the human never leaves the loop.One of the clearest breakdowns of why “smarter chat” is not the same as “software that can run without you.”Together with this Jev AI Guide, you will be able to build AI agents, workflows, and decision systems on a model that’s 200x faster & 400x cheaper than LLMs 🤖: https://lnkd.in/dxNeiCaAInstead of another Netflix series tonight, watch this talk.

LLM vs JevThe LLM side is the familiar autoregressive setup. It generates one token, then the next, until the response is complete. Even if the final output is JSON, it is still produced as a sequence of tokens.Jev works differently. You give it some state and typed questions, and it returns typed probabilistic answers rather than generating a string.Those questions can be a Choice, a Score, or a Noul. Choice picks from a fixed set, Score rates the state along ordered levels and can return a position between them, and Noul returns the probability that a statement is true.If several questions use the same state, Jev can evaluate them together, independently and in parallel.

What if we stopped using an LLM for every decision in an AI system?A concept I find interesting is Jev as a fast decision & routing layer.Instead of:User → LLM → Decide → ExecuteThink:User → Jev → ML / LLM / Tools → Action🎯 Jev could handle things like:- 🔍 RAG routing: keyword vs semantic vs entity search- 📄 Document routing: selecting the right ML pipeline- 🛠️ Agent tool selection- 🚦 Confidence-based escalation from ML → LLM → humanThe idea isn't to replace ML or LLMs.It's to use the right model for the right job:⚡ ML → prediction🧠 LLM → complex reasoning🎯 Jev → fast decisions & routing⚙️ Tools → deterministic executionThis could mean lower cost, lower latency and more controllable AI systems, particularly for enterprise RAG and agentic applications.

Train your own LLM from scratch!A step-by-step repo that walks you through building and training a transformer model from scratch using PyTorch. From downloading training data all the way to generating text.The architecture is built from the ground up following the original "Attention is All You Need" paper. MLP, single head attention, multi-head attention, transformer blocks, and the full transformer model - all coded and explained with detailed diagrams at each step.Training data comes from The Pile - a diverse 825GB open-source dataset covering books, articles, code, websites, and more. The repo includes scripts to download it, preprocess and tokenize it using tiktoken, store it in HDF5 format, and feed it into training batches.You can train a 13M parameter model on a single Colab T4 GPU. At 13M parameters the model starts generating proper grammar and coherent short sentences. For billion-parameter training you need at least an A100 or RTX 4090. The repo includes a full GPU compatibility table so you know exactly what's possible on your hardware.Includes a complete SFT and RLHF guide as a separate notebook for taking your trained model further.Key capabilities:• End-to-end pipeline: data download → preprocessing → training → text generation• Full transformer implementation from scratch with PyTorch• Trains models from 13M to 2B+ parameters on a single GPU• Training data from The Pile (825GB, 22 diverse datasets)• Tokenization via tiktoken (r50k_base)• SFT and RLHF guide included100% open source.I've shared the link in the replies!

AI agents are not just about choosing an LLM.Building a production-ready Agentic AI system requires an entire stack — from the user interface to data ingestion, retrieval, prompting, deployment, and evaluation.Here’s a simple breakdown of the Full Stack of Agentic AI 👇🔹 Frontend — React, Next.js, Streamlit🔹 Document Ingestion — OCR, Apache Tika, Microsoft Fabric, LangChain🔹 Chunking & Preprocessing — preparing data for effective retrieval🔹 Embeddings — converting information into meaningful vectors🔹 Vector Databases — Azure AI Search, PostgreSQL, FAISS, Milvus🔹 Retrieval Layer — finding the right context at the right time🔹 Prompt Engineering — turning context into useful instructions🔹 LLMs — Azure, OpenAI, Llama, Mistral🔹 Infrastructure & Deployment — Docker, Kubernetes, AKS🔹 Observability & Evaluation — monitoring, tracing, and improving AI systemsThe important takeaway?A great AI application isn't just about the model. It's about how all these layers work together.💬 Which layer of the Agentic AI stack are you currently learning or working with?Share it in the comments — I'd love to see what the AI community is focusing on.#AI #AgenticAI #GenerativeAI #ArtificialIntelligence #MachineLearning #LLM #RAG #AIEngineering #LangChain #OpenAI #Azure #Tech

Everyone is fine-tuning LLMs.Almost nobody understands what is actually being updated inside the model.Here are 5 techniques that change how you think about model adaptation, and what each one is actually doing to the weights:1./ LoRA - Learn the update, not the weightsThe pretrained weight W is frozen. Completely untouched.Instead of updating W directly, two small matrices are trained =>A ∈ ℝʳˣᵈ and B ∈ ℝᵈˣʳ, where r ≪ dThe weight update is: ΔW = BA Effective weight: W' = W + BAThe entire adaptation happens in a tiny low-rank space. W never changes.2./ LoRA-FA - What if we freeze even more?Same structure as LoRA. One change.A is frozen alongside W. Only B is trained. Effective weight: W' = W + BA (A is fixed)Half the trainable matrices of LoRA. Same core idea. Fewer parameters.3./ VeRA - What if the matrices don't need to be learned at all?This is where it gets interesting.A and B are both frozen, and randomly initialized. What gets trained are just two tiny scaling vectors =>b ∈ ℝʳ and d ∈ ℝʳInstead of learning the low-rank matrices themselves, VeRA keeps them frozen and learns small scaling vectors that modulate their contribution.Initialization => b = 0, d = 1You're not learning matrices. You're learning how to scale them.One of the most parameter-efficient techniques on this list.4./ Delta-LoRA - What if W itself learns from the low-rank updates?This one is fundamentally different.Unlike standard LoRA, the base weight W is not fully frozen. It is updated through low-rank delta propagation at every step =>W^(t+1) = W^t + c(B_(t+1)A_(t+1) − B_t A_t)Where c is a scaling factor.A and B are trainable. W evolves, but guided entirely by low-rank changes.5./ LoRA+ - Same structure. Smarter learning rates.Identical to LoRA, freeze W, train A and B.One change => B is assigned a larger learning rate than A. η_B > η_AA ← A − η_A · ∂J/∂A B ← B − η_B · ∂J/∂BA small optimization change that can make LoRA training more effective.The core idea running through all five:You do not always need full fine-tuning to adapt a model.LoRA updates two matrices. LoRA-FA updates one. LoRA+ updates two at different speeds. Delta-LoRA lets W evolve - guided by low-rank deltas. VeRA updates two vectors.Same goal. Five different answers to the same question:=> What is the minimum we actually need to learn?That is the core idea behind parameter-efficient fine-tuning.And now you know what is actually happening inside the model.

Finally, an OpenRouter for agent harnesses!(including System One by Jev)Devs just open-sourced a plug-and-play infrastructure layer that lets you run any harness under a single interface, like:- Codex- Hermes- Claude code- DeepSeek Harness- System One, powered by Jev- And 9 more agent harnessesThis means you can bring Jev into the same product that already uses Codex, Claude Code, or another supported harness, without writing another implementation for sessions, streaming, files, cancellation, and failure handling.You can find link to the repo in the first comment.The harnesses run locally, and the Unified Harness Protocol (UHP) defines the common task interface with an OpenAI Responses-compatible API.

This browser agent runs on Jev and does multi-step web tasks in seconds, for a fraction of a cent 👇It's called Jev Ultrafast. Give it a URL and a goal in plain English, and it clicks, types and selects its way through the site.Every decision comes from Jev, TypeSafe's new decision model. It takes the current state and a list of options and picks one (click this, type that, yes/no) in a few hundred milliseconds, with probabilities your code can actually use.Here's how that plays out on a one-way flight search:1️⃣ The agent reads the page and numbers every visible control you can interact with:[1] button · Round trip[2] combobox · Where from?[3] combobox · Where to?2️⃣ Jev reads that list and the goal, and answers with one action and one number. For example, CLICK [1] to change the trip type, or TYPE_TEXT [2] for the origin.3️⃣ If the action is typing, a small LLM (Mercury 2.5) writes the text: "Zurich".4️⃣ The agent acts, reads the page again, and repeats until Jev says DONE.Most browser agents send a screenshot to a big vision model at every step. Jev gets a short text list and makes one pick, with a median decision time of 178 ms. Jev only ever picks an operation and a number from the list. Nothing a model outputs becomes a selector or code, and the agent rechecks the element before acting.Result: the full Google Flights search took 7.1 seconds in real time, including Google's loading, and cost $0.0039.That makes it practical for search on real sites, filling out forms, working with sites that have no API, and prototyping agents cheap enough to run often.Jev Ultrafast hit 14k+ stars on GitHub in just 5 days.

You don't need LangChain to build your first AI agent.You need to understand what an agent is actually doing underneath the framework.A lot of developers start with:→ LangChain→ LangGraph→ Agent frameworks→ Multiple tools→ Memory systemsAnd sometimes miss the most important part:The underlying loop.At its simplest, a Python AI agent can be built around a few moving pieces:🧠 Model — decides what should happen next.🛠️ Tools — Python functions the model can call.💬 Messages — the state/history passed between steps.🔄 Loop — calls the model, executes tools, appends results, and repeats.That's the core.For example:User:“Check order #4182 and tell me if it qualifies for a refund.”The agent can:Understand the task.Decide it needs the order details.Call get_order().Receive the result.Reason over the result.Return the answer.The interesting part is that you control the tool execution.The model doesn't directly execute your Python function.It requests a tool call.Your application decides whether that tool exists, validates the arguments, executes it, and returns the result to the model.And that's where production AI engineering starts becoming important.A demo can stop at:“It works.”A production system needs:→ Maximum step limits→ Argument validation→ Tool-call logging→ Permission gates for risky actions→ Error handling→ Repeatable evaluation tasksBecause an autonomous loop without guardrails isn't an AI system I'd want running against a real database.It's a liability.That's why I'm increasingly interested in understanding the engineering underneath Agentic AI, not just learning another framework.Frameworks are useful.But when you understand the primitives first, you can reason about LangGraph, LangChain, tool calling, memory, orchestration, and agent workflows much more effectively.For Day 12 of my AI engineering carousel series, I broke down how to build a basic AI agent in Python — from the tool function and agent loop to memory, validation, safety, and testing.Save this if you're learning AI agents or LLM engineering.And if you're a business looking for AI agents, AI automation, RAG systems, or custom LLM workflows, comment “PYTHON” or DM me. I'm open to discussing the project.What would you build first with a Python AI agent: a research assistant, a database agent, or an automation agent?#AIEngineering #AIAgents #AgenticAI #Python #LLM #LLMEngineering #GenerativeAI #AIautomation #LangGraph #LangChain #ArtificialIntelligence #AIWorkflows #Automation #BuildInPublic

A coding agent that can install packages, start databases and run shell commands probably deserves its own machine.That is essentially the problem Tensorlake is working on. It gives agents stateful Linux sandboxes backed by Firecracker microVMs, so they can work with files, launch processes and execute generated code inside an isolated environment rather than directly on the host.The more interesting part starts when that environment becomes expensive to prepare.Suppose an agent has already cloned a large repo, installed the dependencies, compiled everything, started Postgres and reproduced a failing test. Doing that setup again for every attempt is wasteful.Tensorlake can snapshot the sandbox at that point. The snapshot preserves the filesystem, memory and running processes, and can later be restored into new sandboxes. The same prepared state can therefore seed one new run or a hundred of them.One agent can try one patch while another starts from exactly the same checkpoint and tries something completely different.The storage work underneath this is also worth looking at.Firecracker’s normal block storage does not keep a record of which disk blocks the guest has modified. Tensorlake added a block overlay that tracks dirty blocks at 4 KiB granularity, so an incremental disk snapshot does not need to copy the entire backing disk.Tensorlake measured a 100 GiB raw disk copy at 101 seconds on its benchmark machine. In a separate test, with 4 GB already on disk, it wrote another 100 MB and took an incremental snapshot. That took 167 ms and produced a 104.9 MB artifact containing 25,614 changed 4 KiB blocks. Those are Tensorlake’s own benchmark numbers, but they make the design very easy to understand: snapshot cost can follow what changed rather than the total size of the disk.There is a useful analogy here.Git made it cheap to branch a codebase. Tensorlake is doing something similar with an agent’s working environment: prepare it once, checkpoint the files, memory and processes, then let several new sandboxes continue from that same point.For coding agents, evals and parallel experiments, that is a very useful primitive.GitHub Repo: https://lnkd.in/dWkqdS4e

FFmpeg’s new human-readable syntax is here."ffhuman convert video.mp4 to gif"Alpaslan Bak built ffhuman after repeatedly Googling and copy-pasting the same FFmpeg commands.Its README puts that one readable line beside a two-command GIF recipe that generates a palette, then applies it to the output.The same readable syntax handles other common jobs: ➡️ ffhuman extract-audio video.mp4 ➡️ ffhuman resize video.mp4 to 1080p ➡️ ffhuman compress video.mp4 to 10mbThe opinionated defaults remain visible. --dry-run prints the generated FFmpeg commands without executing them. --explain describes what ffhuman plans to do.You get a short command for the routine job and a way to inspect the underlying FFmpeg work before processing your file.GitHub repo => https://lnkd.in/eBGrpReCKudos to Alpaslan Bak (https://lnkd.in/edNGdNeY)----------P.S. Turn uploaded videos into stream-ready files without giving up your storage, CDN, or player → https://lnkd.in/eNyUJpYG

HelixDB is an open-source graph-vector database built in Rust for AI memory, knowledge graphs and RAG. Instead of keeping embeddings in one database and relationships in another, Helix stores graph and vector data in the same engine, while also supporting KV, documents and relational data. Queries can combine graph traversal, filtering and vector search in one request, and the current SDKs for Rust, TypeScript, Go and Python send the same structured query AST directly to the server. It can run in memory, on disk, or against S3-compatible object storage.5.7k stars · Apache 2.0GitHub Repo: https://lnkd.in/dvqQ-zFK

The biggest Voice AI architecture decision happens before you choose the model.Do you convert audio into text?Or keep the entire conversation in audio?That choice changes latency, naturalness, control, observability, and even compliance.𝗖𝗮𝘀𝗰𝗮𝗱𝗲𝗱 𝗩𝗼𝗶𝗰𝗲 𝗔𝗜Audio → STT → LLM → TTS → AudioEach component is independently testable and replaceable.→ Swap STT for better jargon accuracy→ Swap the LLM for better reasoning→ Swap TTS without rebuilding everythingThe tradeoff is that errors and latency can compound across the chain.𝗦𝗽𝗲𝗲𝗰𝗵-𝘁𝗼-𝗦𝗽𝗲𝗲𝗰𝗵Audio → Audio-native model → AudioThere is no text checkpoint in the middle.Tone, pace, hesitation, emotion, and interruptions stay in the signal instead of being flattened into text.That can make conversations faster and more natural.𝗖𝗼𝗻𝘁𝗿𝗼𝗹 𝗜𝘀 𝘁𝗵𝗲 𝗕𝗶𝗴 𝗧𝗿𝗮𝗱𝗲𝗼𝗳𝗳A cascaded architecture gives you text you can inspect before speech is generated.That makes it easier to:→ Block forbidden phrases→ Redact PII→ Enforce exact disclosures→ Log conversations→ Debug individual stagesSpeech-to-speech removes that checkpoint, making governance harder.𝗟𝗮𝘁𝗲𝗻𝗰𝘆 𝗜𝘀𝗻’𝘁 𝗝𝘂𝘀𝘁 𝗔𝗯𝗼𝘂𝘁 𝗠𝗼𝗱𝗲𝗹 𝗦𝗽𝗲𝗲𝗱A naive STT → LLM → TTS pipeline waits at every stage.A production pipeline should overlap them.→ Stream partial transcripts→ Start LLM processing early→ Stream the first clause into TTS→ Handle endpointing and barge-in correctlyGood streaming engineering can recover much of the latency gap.𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗦𝘆𝘀𝘁𝗲𝗺𝘀 𝗖𝗮𝗻 𝗕𝗲 𝗛𝘆𝗯𝗿𝗶𝗱You do not always need to choose one architecture for everything.Speech-to-speech can handle the live conversation while parallel transcription supports logging, analytics, policy checks, and quality review.You can also route higher-risk interactions through a controlled text path.The key lesson:If you need to prove and control exactly what was said, the cascaded architecture gives you stronger checkpoints.If naturalness, interruption handling, and conversational feel are the product, speech-to-speech changes the experience.The architecture should follow the requirement, not the hype.👉 Looking to build AI solutions for your business?📞 Book a Free Discovery Call: https://lnkd.in/gD6EwEYt♻️ Repost if this helped.➕ Follow AI Coach John for more production AI breakdowns

Running one agent is easy. Operating a fleet is the hard part.OpenHermit is an open-source platform for deploying fleets of AI agents as services, aimed at teams that need shared operations rather than scattered local state.It helps you run and manage multiple agents by keeping their internal state in PostgreSQL while giving each agent a separate sandboxed workspace.Key features:• Gateway control plane – start, attach, and detach agents from a single server with an admin UI• Postgres-backed state – store sessions, memories, instructions, skills, MCP servers, schedules, and secrets scoped by agent• Sandboxed execution – run each agent in Docker, E2B, or Daytona rather than on the gateway itself• Channel adapters – connect agents through Telegram, Discord, Slack, CLI, or a web UI• Fleet-wide controls – enable skills and MCP servers per agent or across the fleet, with scheduled jobs availableIt’s open-source (MIT license).🔗 GitHub: https://lnkd.in/db2p3zUu⸻♻️ 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

Google just open-sourced ARTEMIS.It lets AI agents control a real phone like a human.You hand the agent a task in plain English and it operates the device end to end: sees the screen, finds the elements, taps, swipes, navigates, verifies the outcome, and reports the result.It connects to your agent over MCP: Claude Code, Codex, Cursor, Windsurf, Antigravity, VS Code, and more.What Google reports:→ 99%+ task completion on AndroidWorld→ 100+ multi-step tasks→ ~3–5 seconds per step in Flash mode→ Targeting that fuses accessibility, OCR, and vision→ Screenshots, execution traces, and diagnostics on every run→ A Python SDK to drop into your test pipelinesThe real shift: your phone turns into an environment an agent can run.Tell Codex to build the APK, install it, log in with a test account, walk the checkout flow, flag any unexpected popups, and return screenshots of the failures, and it drives the device itself.QA, mobile testing, debugging, automation, all of it moves forward. Google just gave AI agents hands for Android.Link: https://lnkd.in/erxwRxyF100% open source. Apache 2.0.