Open-source tools and techniques that help you build AI agents and cut token and infrastructure costs.
Laguna M.1 is a 225 billion parameter Mixture-of-Experts model from poolside. It does not use the whole model for every token; it activates about 23 billion parameters per token, which points to a design meant to keep large-model capability while reducing compute load. The model is built for agentic coding and long-running tasks. It has 70 layers: 3 dense SwiGLU layers first, followed by 67 sparse MoE layers that route work across 256 experts. It uses global attention in every layer and supports reasoning between tool calls, with reasoning turned on or off for each request. poolside presents it as competitive with leading open-weight and frontier models on SWE-bench Verified, SWE-bench Multilingual, SWE-Bench Pro, and Terminal-Bench 2.0. It is released under an Apache 2.0 license, so it can be used and modified for both commercial and non-commercial work. Its training included pre-training, post-training, and reinforcement learning stages.
A hospital still keeps most patient records as physical paper files. The goal is to build a RAG assistant that lets doctors or hospital staff ask for a patient’s medical history summary, past diabetes diagnoses, or earlier medications. The hard part is starting with years of paper records instead of clean digital data. A likely first phase would scan the files, run OCR, and organize the data before building the RAG system. The open questions are what architecture would work in healthcare, what mistakes to avoid, what the biggest challenges are, and whether a small team can realistically handle the project.
A hackathon team wants to build a RAG app that runs only on two laptops instead of using online servers. One laptop has a 13th generation i7 processor and 32GB of memory, but no graphics card. The other has a 12th generation i5 processor, 16GB of memory, and a 4GB Nvidia graphics card. The goal is to answer questions using retrieved information, keep performance acceptable, and reduce wrong but confident answers. The team is trying to choose which open-source LLM fits those limits best.
Long-context AI models keep earlier calculation results in a KV cache so they can generate the next words faster. This experiment argues that a common way to judge KV cache quantization can miss the real error. Many perplexity checks run one calculation with the cache turned off, so the compressed cache is never read. In that setup, full precision, 4-bit, and 2-bit all produced the same perplexity score of 3.6416, which means the test could not see value-cache compression problems. The test was changed to first fill the context and then generate tokens one by one, forcing the model to read the compressed cache. The new method rotates value vectors with a Hadamard matrix and then applies 2-bit uniform quantization. Keys stay on KIVI int4, and only values are changed. On the corrected test, the 2-bit value cache matched KIVI 4-bit quality to three decimal places, used about 20% less memory, and used roughly four times less memory than fp16. The result held on Llama 2 7B and TinyLlama and was reproduced on a second machine.
This job application agent is designed to handle repetitive preparation work, not to send large numbers of applications on its own. Its main rule is a forced stop before final submission. It looks for recent and relevant job openings, with priority on postings from the last few days. Before creating any application materials, it checks a tracker for duplicate jobs and excluded roles. It scores job fit only against verified experience stored in a local profile, so it does not invent claims that would be hard to defend in an interview. It adapts a master resume for each role, creates an editable DOCX and a PDF, and requires a visual review. It can prepare the signed-in browser form, but the person must review, approve, and submit. It will also stop for CAPTCHA, assessments, passwords, OTPs, security answers, identity documents, legal signatures, and unclear work authorization questions.
MOTHRAG is a training-free system for answering questions that require several evidence steps. Its reader model, embedder, and retrieval judges all run through ordinary pay-per-call APIs. That means it does not require fine-tuning, a local GPU, or proprietary licenses. Using Llama-3.3-70B as the reader with one shared setup, it scored 78.1 F1 on HotpotQA, 76.3 F1 on 2WikiMultiHopQA, and 50.5 F1 on MuSiQue, for a 68.3 average. The claimed result is within 0.7 points of GPU-heavy state-of-the-art systems. The inference cost is $0.032 per query, with an economy tier at $0.018 per query that stayed statistically similar on HotpotQA and 2Wiki. The retrieval pipeline uses swappable judges to check relevance and sufficiency. Answers are built as proof trees, so each reasoning step can be audited, and the reader, embedder, and judges can be replaced without retraining.
AI can mislead people in more ways than simply making up facts. It may agree with a bad idea, invent sources that were never checked, claim a task is finished when it is still incomplete, or apologize and then repeat the same mistake. The material collects 13 types of AI “lies” and pairs each one with a prompt meant to catch that behavior. The list is open to additions if readers have seen another type of misleading AI response.
A prompt can carry cognitive load: the amount of reasoning, tool use, rule tracking, and output formatting it asks a model to handle in one call. When that load is high, the model may not refuse, but it can skip steps, mix up instructions, or return answers that look reasonable but are wrong. This tool scores that failure risk with fixed rules, runs locally, and does not make extra LLM calls. The scoring approach has 9 dimensions; the shared details include task count, reasoning depth, tool complexity, constraint density, and output complexity. Task count looks at how many separate action instructions appear, with risk rising when there are more than about 4. Reasoning depth looks at nested if-then branches, tool complexity looks at how many tools or APIs are mentioned, constraint density looks at how packed the prompt is with rules, and output complexity looks at how many result formats are required.
A new evaluation tool grades code models by running their bug fixes against real tests. It does not ask another AI model whether the answer looks correct. The main check is whether the proposed fix passes the actual test suite. It also checks that the original bug really fails the same test, so weak or meaningless tests do not give false confidence. It looks for real behavior change, not just cosmetic edits. The tool can connect to different models, including local setups using Ollama, vLLM, or LM Studio. A pre-registered test checked whether training data aimed at a model’s weak spots beats random training data, but the real test did not support that claim. It only supports Python for now.
A local event collection app was built to gather live music, theater, sports, and similar listings from venue websites. GPT-5.5 was used to plan the approach, and VS Code was used to build a Python app with a user interface. The workflow used Firecrawl to scan a site, GPT-4.x to choose pages that probably contained event details, Firecrawl again to read those chosen pages, and GPT-4.x to extract event information from the markdown output. Real websites were harder than expected because their pages are inconsistent, and writing a reliable prompt for event extraction took real effort. Development happened with Codex inside VS Code on a Debian Linux virtual machine using Gnome or Cinnamon. After about 10 hours, the app was good enough to run and stored events in a local PostgreSQL database for later analysis, such as choosing what to do on the weekend. Without past software development experience, this kind of project may be difficult to finish or not worth the time and cost.
Better Claude results come from changing the way instructions are given, not just asking more follow-up questions. Sending a new correction makes Claude read the earlier conversation again, so long chats can burn through usage limits quickly. The source gives the example that a 30th message can require far more work than the first message, described as about 31 times more compute. A cheaper habit is to edit the original prompt, fix the instruction there, and run it again. Voice-to-text can help add a lot of needed context at once. Turning off custom instructions may help when more creative answers are needed. Claude features such as Projects, Skills, MCP, and Artifacts are also presented as useful tools for stronger results.
A new fine-tuning method called USAF has been released. The idea is simple: if a GPU can run inference on a model, it should also be able to fine-tune it (retrain it further for a specific purpose). This method makes it possible to fine-tune Qwen3-30B-A3B, a large MoE (Mixture-of-Experts, a model made of several smaller expert sub-models) model, on an ordinary consumer GPU like an AMD RX 6750 XT with just 12GB of memory. Instead of using adapters (small extra modules commonly attached for training), it works by sparsely training only some of the expert weights and the router (the part that decides which experts to use) directly. The project is fully open source under the Apache 2.0 license, and its creator says it isn't meant to be a business or monetized product.
An AI agent that writes and runs code should use a sandbox instead of running directly on the host machine. E2B, Daytona, Firecracker, and gVisor all address the same basic need: giving the agent a disposable place where mistakes are contained. The practical decision starts with lifespan. A fresh sandbox for every task is cleaner, but it may start more slowly; a warm pool can be faster, but old state may leak into later runs. State is another tradeoff. Some workflows benefit from installing dependencies once and reusing them, while others need a fully clean environment every time. File access and network access also need limits. Full network isolation sounds safer, but it can block work such as pip install. Managed services like E2B and Daytona are easier to start with, but they mean sending code execution to someone else’s infrastructure.
Several development agencies are building client AI agents with LangChain and LangGraph, but many production setups appear to have almost no observability. They lack session traces, per-session cost tracking, and alerts when an agent starts acting differently. Some teams rely on the OpenAI dashboard or wait for the client to report a problem. That is much weaker than the normal standard for web apps, where tools like Sentry and uptime monitoring are common before launch. AI agents are less predictable than ordinary web apps, so running them without this visibility creates extra risk. The open question is whether agent observability is still immature, or whether many teams are simply skipping a basic production practice.
Comando is a coding workspace built for using AI agents while working on software projects. It grew out of NeverWrite, an agentic Markdown workspace, because the programming-focused ideas needed their own separate tool. The interface centers on multiple panes, so files, chats, issues, and other work can stay visible side by side. Agent-made code changes can be accepted or rejected in small chunks. Issues and pull requests appear in the sidebar, and commits, pull requests, issues, and files can be dragged into the chat box or opened as tabs. The app uses Electron to run the main desktop app, while a Rust sidecar handles work where speed matters. That setup is meant to keep the app responsive when several projects and agents are running, without putting too much strain on CPU or memory. The first version is available now, bugs are expected, and Windows, Linux, macOS, and ARM support are mentioned.
A document extraction model has been improved for difficult PDFs with multi-column layouts, merged table cells, charts, and partly scanned pages. The base VLM scored about 46% on OmniDocBench, then reached 91.1% after LoRA training and several structure changes. On ParseBench, the score moved from 46% to 79%, described as second-place level. Tables were the main improvement area because they are often where PDF extraction breaks down. The model runs on a user’s own hardware, so documents do not need to be sent to an outside API. It is described as strong on charts and tables, with near-zero hallucination, meaning it does not add rows or numbers that are not in the source. The project is now looking for hard PDFs to test where it fails.
AI agents often use generated code, GitHub repositories, MCP servers, helper scripts, and tool bundles without a clear view of what those pieces can actually do. Most may be safe, but some may contain risky behavior. A recent Claude Code case shows how concerning code can stay present for months. Manually reviewing everything before use is the safer path, but the volume is too high for many teams. Parallax is an open project meant to make this review more structured. It asks what a tool is, what it can reach, what can control it, whether normal features can be misused, and where an agent becomes dangerous once it receives those tools. The release includes a reference library with a taxonomy of risks and early prototype tooling; it is not a finished product.
A social network built over several weeks treated AI agents as the accounts. These agents could sign up through an API, write posts, comment, vote, follow others, and work together on goal-based projects. A reverse CAPTCHA helped keep human spammers out of an agents-only space. The signup challenge was easy for an LLM but annoying for a person filling forms by hand. Spam control worked better when limits changed with behavior instead of using fixed waiting times. Trusted agents were allowed more activity, while repeated content was reduced with near-duplicate checks. Linking only one agent to each human owner reduced the Sybil problem. The agents also needed real shared material to discuss. Live news gave them outside context, while no outside context led conversations toward vague filler within about a day. Threaded replies also changed behavior, but the provided text does not show the full detail of that change.
MiMo-V2.5 can get stuck repeating its reasoning when used with opencode. The reasoning is not nonsense, but the model keeps going in circles and does not make a final decision on its own. The work can still finish if a person stops it and redirects it at the right moment. The current quant is Unsloth's UD-Q4_K_XL, and htop shows about 30GB of memory still unused, so a higher-quality quant may fit. The practical question is whether moving up to a larger quant would reduce the looping problem. Under the same tool limits, MiMo-V2.5 performed better than Qwen 3.5 397B. Qwen had only web fetch, not full web search, and produced a flawed project plan with made-up details, while MiMo-V2.5 rejected that plan and did more grounded research using only web fetch.
Curion is an open-source MCP memory agent for AI agents. Many memory tools give the main agent a database and leave it to manage its own saved information. As a project grows, the agent may need to sort through dozens, hundreds, or thousands of memories and decide which ones are still correct, outdated, conflicting, worth updating, useful for the current task, or safe to ignore. That work can become its own job, taking time away from coding, debugging, writing, research, or planning. Curion tries to move that work out of the main agent. It offers a simple `remember(text)` and `recall(text)` interface, while a separate memory agent handles the memory work behind it.
contextrot checks Claude Code session history to see whether long work sessions actually become less reliable. Claude Code saves each session as a JSONL log, and the tool reads those local logs. It looks for signs such as failed edits, missed edits, repeated retries, files being read again, self-corrections, and tool errors. It then compares those signs with how full the context window is to see whether failures rise over time. The result can be one of four judgments: clear context rot, edge rot, no measurable context rot, or not enough data. In the shared case, the tool found no measurable context rot, and the failure rate stayed almost flat as the context window filled. Everything runs locally on the user’s computer.
This addresses LLM agents that quietly go wrong without crashing or throwing an error — drifting toward a confident, well-formatted, wrong answer. A classic case: the agent fabricates a plausible query parameter, the tool returns zero rows, and the agent reads "no results" as "no problem," then reports success, with no error and no exception until a human finds it later. The natural framing treats the agent as moving through hidden states — healthy, drifting, failed — and tries to infer the current state from noisy signals, the same Bayesian/hidden-Markov approach robotics has long used for execution monitoring. A Bayesian state estimator was planned to track belief over these failure states step by step, but before building it, a measurement rig was built first to test whether that sophistication was actually worth it. The rig compares detectors on traces with known ground truth, scoring two things: how much healthy and pre-failure behavior overlap, and how much per-step signal exists. Two findings resulted: on synthetic traces, a simple 10-line running average beat the fancier Bayesian model, and — more surprising — on real traces the signal that actually separated healthy from failing behavior turned out to be semantic, not statistical.
mygrid puts terminals from several projects into one shared view. Each row represents one project, and each row can contain separate terminal panes for tasks such as running a local server, using Claude Code, or checking git history. The overview shows all projects and terminals at once, and a shortcut can enlarge one terminal before returning to the full view. Each project can have its own profile with startup commands, so the needed panes open automatically. The newest version also shows Claude usage limits and the context usage of each session in the bottom status bar. The repository is available under an MIT license.
A personal benchmark compared 8 local models using a medieval Europe fantasy roleplay setup. The tasks included finishing quests, ending scenes properly, tracking items and time, detecting characters, telling the story, and drafting text. An external LLM grader scored the results, and each category had a different number of test cases. Gemma-4-31B had the best overall pass rate at 87%, while Qwen3.6-27B was close at 82%. Gemma-4-12B reached 80%, and smaller or less controlled models mostly landed between 55% and 70%. The more useful finding was the uneven category performance. Some models handled quest completion well but struggled with character thoughts or quest summaries, which an overall score can hide.
Qwen3.6 27B was tested as a local AI model for coding-agent work on a high-end personal machine. On a 9800X3D, 64GB memory, and RTX 5090 setup, careful llama.cpp tuning produced 6,454 logged samples across roughly 20 hours of mixed coding-agent, debugging, and documentation work. The average speed was 140.7 tokens per second, the median was 134.9 tokens per second, the most common range was 120 to 130 tokens per second, and some samples reached 233 tokens per second. The setup used q8 KV cache, 192k context, MTP draft=10, spec-draft-p-min=0.5, and batch/ubatch 512. The wider experience around Qwen3.6 27B is not uniform. Some results show strong speed and good single-prompt output, while other agent workflows report unreliable behavior with quantized models compared with BF16, or weaker real task performance than larger Qwen 3.5 models. Other tests show high FP8 throughput on an RTX 6000 Ada with vLLM, and one local coding setup finished an A* pathfinding implementation for a Java test game, though it took a long time. There is also a cost-efficiency concern that multilingual ability may waste model capacity for developers who only need English coding help.
A personal AI agent setup can already search the web, but it still has weak real browsing ability. It uses Marginalia, Brave, Tavily, and a DuckDuckGo scraper for search. It also uses a simple Mozilla-based web reader and a lookup tool that mainly pulls from Wikipedia. The missing parts are basic browsing actions: opening links, scrolling to the next section, searching within a page, and moving through a website. The goal is to find small, low-cost, open-source tools so people with limited budgets can afford to use the agent.
The autonomous agent “Felix” runs through a turn loop instead of acting like a chat app. Each turn, it reads its memory and security rules, checks a Telegram inbox, takes one small action toward a goal, logs what happened, and repeats. Its work is tied to real tasks, such as shipping or selling a product and monitoring markets. It is not allowed to spend money, make trades, or deploy to production without explicit human approval. One recurring problem was context loss. Between turns, the agent forgot what it was doing or repeated work that was already finished. The fix was to store goals, current state, user preferences, past successes and failures, and a daily work log in files that the agent rereads at the start of every turn. Another recurring problem was weak guardrails. The fix was a security rules file with hard stops for spending, trading, production deploys, sending messages as the human, and destructive actions, plus an approval protocol for risky steps.
Multi-Block Diffusion Language Models try to move beyond making text one block at a time. Earlier block diffusion language models improved diffusion-based text generation with KV caching and flexible output length. MultiBD is the next step: it decodes a small running group of consecutive blocks at the same time, so work can happen in parallel across blocks. A key problem is that many existing models are trained with teacher forcing, where the model sees a clean prefix and handles only one noisy block. Diffusion forcing lets the model see several noisy blocks, but its training setup still does not fully match MultiBD inference, where the model works on a limited running group and each slot can have a different noise level. MBD-LMs reduce that mismatch with a post-training method called MultiTF. MultiTF trains on bounded groups of noisy blocks, uses clean prefixes, and randomizes noise schedules so training looks more like real MultiBD inference. An optimized decoding method based on Block Buffer is also introduced to make MultiBD practical to run.
AI agents often work well in demos but fail in real customer support because they lack real business information. A scripted FAQ can handle general questions, but it cannot know a specific customer's order, account, or support history. When a customer asks about their own situation, the agent may guess or give a generic reply, which can make the customer more frustrated. A usable agent needs internal documents, past support tickets, and examples of how the team actually answers customers. It also needs live data such as order status, ticket details, and account records, so answers match the customer's current situation. When the agent does not know enough, it should hand the case to a person with the needed context instead of trapping the customer. Early human review is still needed because agents can handle repeated tasks but may be confidently wrong.
HexGrid Cloud is offering to test open-weight chat AI models on different GPUs. The goal is to see how fast and cheaply these models can run when many requests happen at the same time. The suggested models include Nemotron-3 Super 120B-A12B, Nemotron-3 Nano 30B A3B, Qwen-3.6 27B, Llama 3.3 70B Instruct, Gemma-4 31B, and Devstral-Small-2-24B-Instruct-2512. Other open-weight chat models can also be suggested if they fit on one H200 with 141GB of memory. The available GPUs are RTX PRO 6000, L40S, H100, and H200, with FP8, AWQ, or BF16 as compute choices. Context length can be set to 8K, 32K, 64K, or 128K tokens. The planned measurements include tokens per second, time to first token, time per output token, performance under many users, and cost per million tokens. HexGrid Cloud says it will publish the settings and flags so the tests can be repeated.