Committee

arXiv:2607.15655v1 Announce Type: new Abstract: Masked diffusion language models (DLMs) enable parallel text generation by iteratively refining masked tokens, offering a promising alternative to autoregressive decoding. Recent lookahead-based decoding methods improve the accuracy–efficiency trade-off by exploring future decoding states before committing token updates. However, existing approaches mainly rely on shallow one-step lookahead, which optimizes immediate information gain but can be suboptimal for longer-horizon decoding trajectories. Meanwhile, we find that a naive extension for deeper lookahead is also ineffective, as fixed-depth rollout introduces additional computation and cannot adapt to heterogeneous intermediate decoding states. Thus, in this work, we propose AdaLook, an adaptive lookahead framework for DLM decoding. AdaLook dynamically determines whether to continue rollout based on candidate-score variance and further enables branch expansion when intermediate rollout states require additional exploration. This design avoids unnecessary deep rollout while allowing the decoder to re-trigger lookahead from informative intermediate states. Experiments on various benchmarks and models demonstrate that AdaLook achieves a better accuracy–decoding steps trade-off than existing one-step lookahead decoding methods.

The next time you apply for a job, AI may screen your résumé before any human sees it. But there’s good reason to question whether AI will judge you fairly. Researchers already know that LLMs pick up human biases from their training data. New research suggests that LLMs can also develop their own biases from experience—and stereotype job applicants more than humans do. As AI companies race to build agentic models that remember the tiniest details about users, they may be handing them ammunition for forming those biases.  Researchers at Princeton University and the University of Chicago ran LLMs, including ChatGPT, Claude, and Gemini, through a simulated hiring game, adapted from a psychology study that explored how humans can form stereotypes. Each model was told it had been hired as a consultant by the mayor of a fictional city and was then asked to help hire people for 20 jobs, including doctors, lawyers, child-care aides, and janitors. Candidates came from four fictional ethnic groups: Tufa, Aima, Reku, and Weki.  In each round, there was a new job opening and four candidates, one from each group. After the model hired a candidate, it learned whether they succeeded at their job and moved onto the next round. The model was told to make as many successful hires as possible over 40 rounds. Unbeknownst to the models, all candidates were equally likely to succeed at every job. The models quickly started segregating candidates from different groups into different jobs on the basis of early observations of hiring outcomes. For example, when a model was told an Aima had failed as a doctor, a job considered to require high levels of warmth and competence, it veered away from hiring all Aimas as doctors. Instead, it started hiring Aimas as janitors, which the model classified as being less warm and competent than doctors.  The models were even more likely to stereotype people by demographic group than the human participants in the original study. On the study’s segregation scale, where 2 means every group has been completely confined to its own job niche, human participants scored 0.84. The models scored roughly 65% higher, with OpenAI’s reasoning model o3 scoring 1.83, close to the maximum possible. That’s because LLMs “really are eager to create generalizations from limited data,” says Ryan Liu, a PhD student at Princeton University and a coauthor of the study, which was published in a paper at ICML in Seoul in July. “That’s literally a lot of what they’re optimized for.” Every decision-maker, human or machine, faces a trade-off between sticking with what worked before and trying something new that might work better—a phenomenon psychologists call the “exploration-exploitation dilemma.” It’s like choosing between a new restaurant and your reliable favorite.  Because LLMs are trained on math, coding, and science problems—tasks that reward generalizing from just a few examples—they can settle on a hunch too early. And the same instinct that helps LLMs crack logic puzzles also makes them quick to stereotype. In the experiment, newer models with higher reasoning capabilities, such as OpenAI’s o3 and DeepSeek’s R1, showed even stronger biases. When LLMs rush to generalize in social settings, “that’s when things tend to go wrong,” says Liu. OpenAI and Anthropic did not respond to requests for comment. The finding is especially relevant now that chatbots are gaining improved memory and personalization features, says Angelina Wang, a computer scientist at Cornell University who did not work on the study. When a chatbot draws on its previous conversation history, it can “over-index on the same kinds of behaviors it’s experienced before” and form biases, she says. Simply having chatbots remember less isn’t a fix, though, because users want chatbots to remember what they say. “We still are trying to figure out just the right amount that isn’t too much or too little,” says Wang. Telling the model to be fair didn’t change its behavior much. “Either it can’t put these values into action or that process is being submerged under the tendency to try to optimize for the goal of getting the most correct hires,” says Liu. But promising the models an additional bonus for diverse hiring made them far less biased. The trick, then, is to design goals that “incorporate desirable social values in order to make the large language model act in socially desirable ways,” says Liu. The models also became less biased when they were told more personal information about individuals. In another experiment in the same study, the researchers asked the models to resettle members of different ethnic groups in cities across Canada. When the models were told personal information relevant to the ability to adapt to a new city, such as age and education, they were less likely to segregate people by their ethnicity. But when they were given irrelevant information, such as hair color and tattoo shape, the models largely fell back to sorting people by their ethnicity again.  To what extent AI systems will stereotype job applicants in the real world is still an open question. While the models in the experiment immediately learned whether they’d made successful hires, a model screening résumés in the real world doesn’t get an instant report card. Companies can take a long time to find out whether a new hire is any good.  But when feedback does trickle in, a model could still read too much into those results when making future hires. As companies increasingly deploy LLMs to screen résumés and even conduct interviews, the finding that models can form biases from their hiring experience “is a really serious implication that they should grapple with,” says Wang.  As LLMs learn from experience to make decisions about who gets hired, who gets a loan, or who gets parole, the biases we should worry about may include ones no human ever taught them. “These novel biases—they’re sort of ever present,” says Liu.

This story originally appeared in The Algorithm, our weekly newsletter on AI. To get stories like this in your inbox first, sign up here. Over the weekend, several current and former advisors to President Donald Trump on AI publicly lobbed insults at the country’s leading AI companies. David Sacks, the president’s AI and crypto “czar” until March, branded Anthropic’s models as “lobotomized” and “woke.” Emil Michael, a top Pentagon official, called OpenAI’s new head of strategic futures a “supreme village idiot.” It began because no one can agree on what to do about Kimi, a free, open source model that Chinese AI company Moonshot launched last week. It appears to rival the intelligence of models from OpenAI and Anthropic, which are very much not free.  Kimi and other Chinese models like it pose a real problem for Trump. And they’re dividing the top AI strategists in his orbit into factions. Every time a new smart, free model from China like Kimi gets released, US companies see less reason to fork out money to access models from Anthropic or OpenAI. Given that enthusiasm for these and other AI companies is driving an outsized share of economic growth, China’s AI models create both economic and political problems for the president. They are “a threat for an administration that really doesn’t want more economic bad news,” Anton Leicht, a fellow at the Carnegie Endowment, wrote on X. They’ve already rattled US stocks.  What is Trump to do? First, consider that this is all happening just a week after New York imposed the country’s first state ban on new data centers. There is growing distrust of AI companies, and I imagine a not-insignificant share of Americans would have little sympathy for OpenAI or Anthropic as they fend off cheaper competitors, and would say it’s not the government’s job to protect their interests. On this point, they’d see a sliver of agreement (and really just a sliver) with David Sacks, who on July 19 criticized top AI companies that “want the government to eliminate their open source competition.” He has also argued that Chinese AI models have become popular because they come with fewer restrictions on how people can use them (putting aside the built-in state censorship).  Sacks, however, is out of a job. He no longer has a formal role advising Trump, and his position that more open AI is better has been largely replaced in the administration by one that sees a larger role for government intervention. The thinking behind this view is that because AI models have gotten strong enough to pose threats to national security, the government must control how they’re used.  This position has fueled the new White House review process that aims to vet AI models’ security before they’re released. Dean Ball, a former Trump AI advisor who now works for OpenAI, criticized it over the weekend as a “de facto licensing regime for frontier AI.” Ball predicted Trump may solve his Chinese open source problem with a bit of soft power, perhaps by making US companies afraid to use models like Kimi. That drew a response from Michael, who, with Secretary of Defense Pete Hegseth, has been the agency’s main liaison with AI companies. Michael called Ball the AI industry’s “supreme village idiot,” bristling at the suggestion that the government would quietly strong-arm companies rather than, as Michael put it, go through “the democratic process not some Deep State scheme.” Left out of the conversation has been how a model like Kimi got so good in the first place. For much of the Biden administration and even the beginning of Trump’s second administration, keeping China from getting top chips was a priority. Those export controls have loosened—Trump made the controversial decision to allow Nvidia to sell more chips to China, in exchange for the US government taking a cut—and the government has alleged that some chip smuggling has taken place. But China nonetheless has limited computing power, and it’s not clear what chips the company behind Kimi used to train the model.  It’s possible that the process involved some distillation, a practice in which AI models are trained on the outputs of existing AI models. OpenAI and Anthropic have long complained that Chinese AI companies do this, and they have requested government help to put a stop to it. In April, they got it, when the Trump administration announced a series of efforts to curb the practice.   But Kimi is out there and free, and it is nearly as good as the Anthropic model the US government deemed so powerful that it was briefly shut down because it threatened national security. The weekend’s sparring suggests many in Trump’s orbit see that as a wake-up call. But nobody can agree on what for.

In this tutorial, we build an end-to-end NVIDIA NeMo AutoModel workflow in Google Colab and use a single GPU to explore the same configuration-driven training architecture that scales to distributed multi-GPU environments. We verify the available CUDA hardware and precision support, install NeMo AutoModel directly from its source repository, load an official Qwen3-0.6B LoRA fine-tuning recipe, and programmatically adapt its precision, batch-size, checkpointing, and scheduler settings for a constrained Colab runtime. We then launch parameter-efficient fine-tuning through the automodel command-line interface, locate and reload the generated LoRA checkpoint, and compare outputs from the original and fine-tuned models. Finally, we use NeMoAutoModelForCausalLM through the Python API to demonstrate how NeMo AutoModel integrates NVIDIA-optimized execution paths while preserving the familiar Hugging Face model interface. Setting Up the Colab Workspace and Shell Helper Copy CodeCopiedUse a different Browser import os, sys, glob, json, subprocess, shutil, textwrap REPO_DIR = “/content/Automodel” WORK_DIR = “/content/automodel_demo” CKPT_DIR = os.path.join(WORK_DIR, “checkpoints”) os.makedirs(WORK_DIR, exist_ok=True) def sh(cmd, check=True): print(f”n$ {cmd}n” + “-” * 78) p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1) for line in p.stdout: print(line, end=””) p.wait() if check and p.returncode != 0: raise RuntimeError(f”Command failed ({p.returncode}): {cmd}”) return p.returncode We import the core Python libraries required for file handling, process execution, path management, and formatted output. We define the repository, working, and checkpoint directories used throughout the workflow. We also create a reusable shell-command function that streams command output and raises errors when execution fails. Verifying the GPU and Installing NeMo AutoModel Copy CodeCopiedUse a different Browser print(“=” * 78) print(“STEP 0 — Checking GPU runtime”) print(“=” * 78) import torch assert torch.cuda.is_available(), ( “No GPU found! In Colab: Runtime -> Change runtime type -> select a GPU.” ) GPU_NAME = torch.cuda.get_device_name(0) BF16_OK = torch.cuda.is_bf16_supported() VRAM_GB = torch.cuda.get_device_properties(0).total_memory / 1e9 print(f”GPU: {GPU_NAME} | VRAM: {VRAM_GB:.1f} GB | bf16 supported: {BF16_OK}”) print(“n” + “=” * 78) print(“STEP 1 — Installing NeMo AutoModel (takes a few minutes)”) print(“=” * 78) if not os.path.isdir(REPO_DIR): sh(f”git clone –depth 1 https://github.com/NVIDIA-NeMo/Automodel.git {REPO_DIR}”) sh(f”pip -q install -e {REPO_DIR}”) sh(“pip -q install pyyaml peft”) sh(‘python -c “import nemo_automodel; print(‘NeMo AutoModel version:’, ‘ ‘getattr(nemo_automodel, ‘__version__’, ‘source’))”‘) We verify that the Colab runtime provides a CUDA-enabled GPU and inspect its name, memory capacity, and bfloat16 support. We clone the NVIDIA NeMo AutoModel repository when it is not already available and install the package directly from source. We then install the supporting YAML and PEFT libraries and confirm that the NeMo AutoModel package imports correctly. Loading and Patching the Qwen3 LoRA Recipe Copy CodeCopiedUse a different Browser print(“n” + “=” * 78) print(“STEP 2 — Preparing the recipe”) print(“=” * 78) import yaml candidates = sorted(glob.glob( os.path.join(REPO_DIR, “examples”, “llm_finetune”, “qwen”, “*0p6b*peft*.yaml”) )) or sorted(glob.glob( os.path.join(REPO_DIR, “examples”, “llm_finetune”, “**”, “*peft*.yaml”), recursive=True, )) assert candidates, “Could not find a PEFT recipe in the cloned repo.” BASE_RECIPE = candidates[0] print(f”Base recipe: {os.path.relpath(BASE_RECIPE, REPO_DIR)}”) with open(BASE_RECIPE) as f: cfg = yaml.safe_load(f) print(“n— Original recipe (as shipped) —“) print(yaml.dump(cfg, sort_keys=False)[:2500]) def patch(node): if isinstance(node, dict): for k, v in list(node.items()): if isinstance(v, str) and not BF16_OK and v.lower() in ( “bf16”, “bfloat16”, “torch.bfloat16”): node[k] = “float32” elif k in (“batch_size”, “local_batch_size”) and isinstance(v, int): node[k] = min(v, 4) elif k == “global_batch_size” and isinstance(v, int): node[k] = min(v, 8) else: patch(v) elif isinstance(node, list): for item in node: patch(item) patch(cfg) cfg.setdefault(“step_scheduler”, {}) cfg[“step_scheduler”][“max_steps”] = 40 cfg[“step_scheduler”][“ckpt_every_steps”] = 40 cfg[“step_scheduler”][“num_epochs”] = 1 if isinstance(cfg.get(“checkpoint”), dict): cfg[“checkpoint”][“enabled”] = True cfg[“checkpoint”][“checkpoint_dir”] = CKPT_DIR DEMO_RECIPE = os.path.join(WORK_DIR, “qwen3_0p6b_colab_lora.yaml”) with open(DEMO_RECIPE, “w”) as f: yaml.dump(cfg, f, sort_keys=False) print(“n— Patched recipe (what we will actually run) —“) print(yaml.dump(cfg, sort_keys=False)[:2500]) MODEL_ID = “Qwen/Qwen3-0.6B” try: MODEL_ID = cfg[“model”][“pretrained_model_name_or_path”] except Exception: pass print(f”nBase model: {MODEL_ID}”) We locate an official PEFT recipe, load its YAML configuration, and inspect the original training settings. We recursively adapt the precision and batch size parameters to fit the recipe on a single Colab GPU while preserving its original structure. We also limit the training duration, configure checkpoint output, save the patched recipe, and extract the Hugging Face model identifier. Running LoRA Fine-Tuning on HellaSwag Copy CodeCopiedUse a different Browser print(“n” + “=” * 78) print(“STEP 3 — Training (LoRA fine-tune of Qwen3-0.6B on HellaSwag)”) print(“=” * 78) env_prefix = “HF_HUB_ENABLE_HF_TRANSFER=0 TOKENIZERS_PARALLELISM=false” rc = sh(f”cd {WORK_DIR} && {env_prefix} automodel {DEMO_RECIPE}”, check=False) if rc != 0: print(“nRetrying with legacy CLI syntax…”) sh(f”cd {WORK_DIR} && {env_prefix} automodel finetune llm -c {DEMO_RECIPE}”) We launch Qwen3-0.6B LoRA fine-tuning on the HellaSwag dataset through the NeMo AutoModel command-line interface. We turn off unnecessary Hugging Face transfer and tokenizer parallelism features to keep the Colab run more predictable. We also include a fallback command that supports older NeMo AutoModel CLI syntax when the primary invocation fails. Comparing Base and Fine-Tuned Model Outputs Copy CodeCopiedUse a different Browser print(“n” + “=” * 78) print(“STEP 4 — Evaluating: base model vs LoRA fine-tuned model”) print(“=” * 78) from transformers import AutoModelForCausalLM, AutoTokenizer DTYPE = torch.bfloat16 if BF16_OK else torch.float32 PROMPT = (“A man is sitting on a roof. He starts pulling up roofing shingles. ” “What happens next?”) def generate(model, tok, prompt, max_new_tokens=60): inputs = tok(prompt, return_tensors=”pt”).to(model.device) with torch.no_grad(): out = model.generate(**inputs, max_new_tokens=max_new_tokens, do_sample=False, temperature=None, top_p=None, pad_token_id=tok.eos_token_id) return tok.decode(out[0][inputs[“input_ids”].shape[1]:], skip_special_tokens=True) tok = AutoTokenizer.from_pretrained(MODEL_ID) base = AutoModelForCausalLM.from_pretrained( MODEL_ID, torch_dtype=DTYPE, device_map=”cuda”) print(“n[BASE MODEL]”) print(textwrap.fill(generate(base, tok, PROMPT), 90)) ckpt_glob = sorted(glob.glob(os.path.join(CKPT_DIR, “**”, “model”), recursive=True)) if not ckpt_glob: ckpt_glob = sorted(glob.glob(os.path.join(WORK_DIR, “**”, “adapter_model.safetensors”), recursive=True)) ckpt_glob = [os.path.dirname(p) for p in ckpt_glob] if ckpt_glob: ADAPTER_DIR = ckpt_glob[-1] print(f”nFound checkpoint: {ADAPTER_DIR}”) try: from peft import PeftModel tuned = PeftModel.from_pretrained(base, ADAPTER_DIR) print(“n[FINE-TUNED MODEL (base + LoRA adapter)]”) print(textwrap.fill(generate(tuned, tok, PROMPT), 90)) except Exception as e: print(f”nCould not auto-load the adapter with peft ({e}).”) print(“Inspect the checkpoint contents manually:”) for p in glob.glob(os.path.join(ADAPTER_DIR, “*”))[:20]: print(” “, p) else: print(“nNo checkpoint found — check the training logs above.”) del base torch.cuda.empty_cache() We load the tokenizer and base causal language model, generate a deterministic response, and establish a baseline for comparison. We search the training output directories for the latest LoRA checkpoint or adapter files created during fine-tuning. We then attach the adapter with

Three Chinese labs now hold the top of the open-weight leaderboard. Moonshot AI’s Kimi K3, DeepSeek V4 Pro, and Zhipu AI’s GLM-5.2 are all sparse Mixture-of-Experts (MoE) models with million-token context windows. Each targets long-horizon coding and agent workloads. This article compares them on three axes an AI team actually decides on: measured capability, license terms, and serving cost. ‘Trillion-parameter’ fits Kimi K3 (2.8T) and DeepSeek V4 Pro (1.6T). GLM-5.2 is 744B total, so it is the smallest of the three by total parameters. It earns its place because it led the open-weight field before K3 shipped. The three contenders Kimi K3 is a 2.8-trillion-parameter Stable LatentMoE model activating 16 of 896 experts per token. Moonshot has not published the exact active-parameter count. K3 adds native vision, a 1M-token context window, and always-on reasoning. Moonshot calls it the first open 3T-class model. Our launch coverage is here. DeepSeek V4 Pro is a 1.6-trillion-parameter MoE with 49B active parameters, using 384 routed experts plus one shared expert. It carries a 1M-token context window with 384K max output. A smaller V4 Flash variant (284B total, 13B active) covers cheaper workloads. Weights are on Hugging Face. GLM-5.2 is a 744-billion-parameter MoE with roughly 40B active parameters and a 1M-token context window. Zhipu ships it with High and Max reasoning modes. It comes with API access Spec Kimi K3 DeepSeek V4 Pro GLM-5.2 Total parameters 2.8T 1.6T 744B (753B per Artificial Analysis) Active parameters Not disclosed (16/896 experts) 49B ~40B Context window 1M 1M (384K max output) 1M (131K max output) Modality Text + vision + video Text Text Released July 16, 2026 April 24, 2026 June 13, 2026 Benchmarks Vendor-reported scores use different harnesses, so per-benchmark numbers rarely line up cleanly across labs. The neutral comparator is the Artificial Analysis Intelligence Index, which scores all three on the same suite. On that index, Kimi K3 scores about 57, DeepSeek V4 Pro (Max reasoning) scores 44, and GLM-5.2 scores 51. K3 ranks #3 overall, behind only Claude Fable 5 and GPT-5.6 Sol, and comparable to Opus 4.8 and GPT-5.5. GLM-5.2 held the top open-weight spot until K3 shipped. Coding benchmarks tell a similar story with caveats. Moonshot’s own table runs K3 and GLM-5.2 through matched harnesses. There, K3 leads GLM-5.2 on every shared benchmark by wide margins. Benchmark (Moonshot harness) Kimi K3 GLM-5.2 DeepSWE 67.5 46.2 Program Bench 77.8 63.7 Terminal Bench 2.1 88.3 82.7 FrontierSWE 81.2 67.3 SWE Marathon 42.0 13.0 Automation Bench 30.8 12.9 GPQA-Diamond 93.5 91.2 DeepSeek does not appear in Moonshot’s table, so its numbers come from separate testing. DeepSeek-V4-Pro-Max scores 80.6% on SWE-bench Verified, the highest open-weight result at its release and tied with Gemini 3.1 Pro. It also posts 83.5 on MRCR 1M, confirming serious long-context ability. GLM-5.2 scored 62.1 on SWE-bench Pro, edging GPT-5.5 at 58.6. So, K3 is the strongest of the three on measured capability. DeepSeek V4 Pro is competitive on isolated coding tasks. GLM-5.2 trails K3 but remains a capable open-weight option. License All three ship as open-weight models, but the practical status differs today. DeepSeek V4 Pro is MIT-licensed, with weights on Hugging Face from day one. GLM-5.2 is also MIT-licensed, with full weights on Hugging Face under the zai-org organization. Both allow unrestricted commercial use, fine-tuning, and self-hosting now. Kimi K3 is the exception. Moonshot has committed to publishing weights by July 27, 2026, expected under a Modified MIT license. Until then, K3 is usable only through the API and Kimi apps. Moonshot’s recent Modified MIT terms add one attribution clause. It triggers only above 100M monthly active users. Serving cost API list pricing separates these models sharply. Model Input ($/MTok) Output ($/MTok) Cached input Kimi K3 3.00 15.00 0.30 DeepSeek V4 Pro 0.435 0.87 ~0.0036 GLM-5.2 1.40 4.40 0.26 DeepSeek V4 Pro is the cost leader by a wide margin. At list output rates, one dollar buys roughly 1.15M output tokens from V4 Pro, about 227K from GLM-5.2, and about 67K from K3. Artificial Analysis prices every model on one blended 7:2:1 cache/input/output basis, which removes vendor framing. On that basis it lists K3 at $2.31 per 1M tokens, GLM-5.2 at $0.90, and DeepSeek V4 Pro at $0.18. On cost per task, the same source reports K3 at $0.94, GLM-5.2 at $0.32, and DeepSeek V4 Pro at $0.04. Speed also differs. Artificial Analysis measures GLM-5.2 at about 168 tokens/sec, well ahead of DeepSeek V4 Pro and Kimi K3 at about 62 each. Moonshot reports above 90% cache hits in coding workloads, which drops K3’s effective input cost to $0.30 per million. Self-hosting is a different constraint. GLM-5.2 at 744B needs over 1TB of VRAM in BF16, or roughly 8x H200 at FP8. DeepSeek V4 Pro at 1.6T needs more still. Kimi K3 is heaviest: Moonshot recommends 64 or more accelerators, putting local serving out of reach for most teams. K3 uses MXFP4 weights with MXFP8 activations for broader hardware support. Which model for which job For lowest cost per token at strong coding quality, DeepSeek V4 Pro is the clear pick. Its weights are downloadable, its license is clean, and its output price undercuts both rivals. For the highest measured capability, Kimi K3 leads, but at 5x to 17x the output price and no downloadable weights until July 27. GLM-5.2 sits between them: cheaper than K3, faster than both rivals, self-hostable today, and more capable than its size suggests. If you are planning to choose based on verification depth and license clarity favor DeepSeek and GLM now. Buyers chasing peak benchmark scores wait for K3 weights or pay the API premium. Key Takeaways Kimi K3 leads the Artificial Analysis Intelligence Index (~57, #3 overall) but stays API-only until July 27. DeepSeek V4 Pro is the cost leader: ~$0.04 per task and ~1.15M output tokens per dollar at list rates. GLM-5.2 (744B) is the smallest yet fastest (~168 t/s) and self-hostable today under MIT. All three ship 1M-token context; only DeepSeek and GLM have open weights available now. The post Kimi

Introduction Building an LLM application no longer requires wiring orchestration code by hand. A class of open-source platforms now exposes retrieval, agents, and workflows through visual canvases, web UIs, and plain-English prompts. These tools let developers prototype in minutes and self-host for data control. This article reviews ten open-source projects across three jobs: building LLM apps, building RAG systems, and building AI agents. Each entry covers what the tool does, its core capabilities, who it suits, and its verified license and repository. HKUDS AutoAgent Repository: github.com/HKUDS/AutoAgent · License: MIT · Paper: arXiv:2502.05957 AutoAgent is a zero-code agent framework from the University of Hong Kong Data Intelligence Lab. You describe a goal in natural language. The system then constructs tools, agents, and multi-agent workflows without manual coding. It ships an agent editor, a workflow editor, and a ready-to-use research assistant mode. The project is research-backed. Its paper argues that agent frameworks exclude non-programmers, and it reports strong open-source results on the GAIA benchmark. AutoAgent also functions as an open alternative to hosted Deep Research products. It works with most major LLMs, including DeepSeek, Grok, and Gemini, and runs through a Docker-based CLI. Best for: researchers and practitioners who want to spin up agents and Deep Research-style assistants from natural language, with a paper and benchmarks behind the framework. Mintplex Labs AnythingLLM Repository: github.com/Mintplex-Labs/anything-llm · License: MIT · Site: anythingllm.com AnythingLLM is an all-in-one, self-hosted platform for RAG, agents, and document chat. It runs as a desktop app or Docker container. The design targets non-technical users while keeping a privacy-first, local-first posture. A no-code Agent Flows builder handles agent logic without scripting. Capabilities include full MCP compatibility, multi-modal input, and embeddable chat widgets. It supports 30-plus LLM providers and multiple vector databases. Documents stay in your environment, which suits teams with strict data rules. The Y Combinator-backed project uses a permissive MIT license, so commercial and multi-tenant use is straightforward. Best for: individuals and small teams that want private document Q&A, agents, and a simple deployment without stitching components together. LangChain Open Agent Platform (OAP) Repository: github.com/langchain-ai/open-agent-platform · License: MIT Open Agent Platform is LangChain’s no-code, web-based interface for building and managing LangGraph agents. It targets non-developers but stays extensible for engineers. Each agent is a configuration layered on a LangGraph graph, so power users can drop into code when needed. Core features include first-class RAG through LangConnect, tool access via MCP servers, and multi-agent orchestration through an Agent Supervisor. Authentication and access control are built in, with Supabase as the default provider. The platform ships pre-built agents, including a Tools Agent and a Supervisor, and can be forked and customized. It is a newer, smaller project than the other entries here. Best for: teams already invested in the LangChain and LangGraph ecosystem that want a GUI layer over their agents. Sim (Sim Studio) Repository: github.com/simstudioai/sim · License: Apache-2.0 · Site: sim.ai Sim is a visual, agent-first workflow builder with a Figma-like canvas. You drag blocks such as Start, Agent, Function, API, Router, and Loop to compose pipelines. An AI Copilot helps assemble workflows, and you can also build in plain English. Built-in tracing and live execution make debugging explicit. The project is Apache-2.0 licensed and YC-backed. It connects to 1,000-plus tools and every major LLM provider, and supports MCP for custom integrations. You can run the hosted version or self-host with Docker. Recent work extends it toward a broader “AI workspace” with conversational orchestration. Best for: teams that want a clean visual canvas, an AI copilot, and production traction under a permissive license. LangGenius Dify Repository: github.com/langgenius/dify · License: Modified Apache-2.0 (SaaS restricted) · Site: dify.ai · Dify is a production-oriented LLM application platform. It combines visual workflow building, RAG pipelines, agent capabilities, and LLMOps monitoring. A Prompt IDE lets you compare model outputs side by side. Fifty-plus built-in tools cover search, image generation, and computation. Dify emphasizes the full lifecycle, from prototyping to observability. Document ingestion handles formats such as PDF and PPT. The project has a large contributor base and is available as Dify Cloud or self-hosted. Note the license: it is a modified Apache-2.0 that restricts multi-tenant SaaS use and requires a commercial license for those cases. Review terms before reselling it as a service. Best for: teams building and operating production LLM apps that need prompt management, RAG, agents, and runtime monitoring in one place. FlowiseAI Flowise Repository: github.com/FlowiseAI/Flowise · License: Apache-2.0 core · Site: flowiseai.com Flowise is a drag-and-drop builder for LLM apps, built on LangChain. You assemble chatbots, RAG pipelines, and multi-agent systems on a canvas. Three builder modes, Assistant, Chatflow, and Agentflow, match rising levels of complexity. Ready-made templates shorten the path from idea to prototype. Flowise is RAG-ready and integrates with 100-plus tools, vector databases, and memory modules. Enterprise features include RBAC, audit logs, observability, and SSO/SAML. You can embed assistants via an SDK or widget. The core is Apache-2.0, but files under its enterprise directory carry a separate commercial license, so check which features you need. Deployment runs locally, in Docker, on major clouds, or through managed Flowise Cloud. Best for: developers who want the lowest barrier to a working LLM app, with an easy jump to embeddable, production-grade assistants. Langflow Repository: github.com/langflow-ai/langflow · License: MIT · Maintained by DataStax Langflow is a visual platform for building AI agents and workflows. Every flow can be exposed as an API or an MCP server, then integrated into apps on any framework. The drag-and-drop editor speeds prototyping, while full Python source access allows deep customization. Features include multi-agent orchestration and integrations with observability tools such as LangSmith and LangFuse. It supports all major LLMs, including local models, and ships a desktop app for Windows and macOS. Its permissive MIT license makes commercial and multi-tenant deployments simple. Treat it as low-code: visual by default, but code-friendly for advanced logic. Best for: developers who want a visual interface over flexible, code-extensible agent and workflow building, with strong observability options. InfiniFlow RAGFlow Repository: github.com/infiniflow/ragflow · License: