agent-memory is a local-first, agent-agnostic long-term memory runtime for AI agents. It stores memories as plain Markdown files, with a rebuildable SQLite index used as a cache rather than the source of truth. Conversation-boundary hooks trigger writes, while an independent sleep-time Manage pass consolidates, ages, and forgets memories by value; unattended deletion is limited to proposals that require confirmation, and superseded or archived material remains available. The runtime provides three recall paths: deterministic MEMORY.md injection at session start, BM25 search with progressive disclosure, and direct access through the store's directory tree using tools such as ls and grep. Memory records use frontmatter for names, abstracts, status, timestamps, links, weights, and provenance, with free-form Markdown bodies. Its CLI, MCP server, and host-agent hooks share the same validation, hash-diff, and reindexing path, and it can be used by agents that run shell commands, including Claude Code and Codex CLI. The repository documents a Python 3.12-or-later setup using uv, commands for initialization, recording, recall, rebuilding, sleep-time consolidation, and proposal approval, plus host setup for Claude Code and Codex. It does not include an LLM client; reasoning is delegated to the host agent's CLI, so the library requires no separate model keys or billing surface.
Bespoke Nimble is an open-source model, training recipe, and local scoring library from Bespoke Labs for making typed decisions about text. Given a context and a flat schema of boolean or fixed-choice fields, it selects an allowed answer and returns candidate logits and probabilities without generating a reasoning explanation or free-form answer. Nimble fine-tunes Qwen3.5-9B with LoRA using contrastive training pairs: two nearly identical examples differ in one relevant fact, which changes the correct label. At inference, the scorer reads the logits for one-token candidate codes and converts them to probabilities with softmax; the Python library constructs the typed result rather than parsing generated JSON. The MLX ParallelScorer processes shared context once and scores fields in parallel, while the CUDA scorer scores each field separately. The repository includes the model recipe, curation and evaluation code, datasets, examples, tests, and deployment documentation. Bespoke-Nimble-9B can run locally on Apple Silicon or an NVIDIA BF16-capable GPU. It accepts text only, does not support nested schemas or answers outside the supplied choices, and its probabilities are not guarantees of correctness.
Codenotch is a macOS app that pins a small notch to a screen edge and displays usage limits, reset windows, and activity states for coding assistants including Claude Code, Cursor, Codex, Antigravity, and GLM. It can show whether a provider is working, finished, or waiting for user input, with separate rings for separate Claude Code profiles and live session details on hover. Each provider adapter reads credentials, sessions, logs, databases, language-server RPCs, or provider endpoints already used by the corresponding local tool; Codenotch does not sign in to services itself. A UsageStore polls the adapters, preserves the last good reading across launches, labels each reading by fidelity, and exposes failures as statuses such as stale, needsAuth, or error rather than inventing a percentage. The notch can be placed on any screen edge, expands when approached, and can be configured to show or hide its Dock and menu-bar icons. The app is written for macOS, supports a demo mode with fixed sample data, and uses Sparkle for signed background updates. Its README notes that the provider interfaces may change because some readings come from internal endpoints or local application state. The project is licensed under the MIT License.
An open-source Codex configuration that uses Astra as the root orchestrator and independent reviewer, with Luna-based subagents for exploration, implementation, testing, and research. It provides separate Pro and Plus profiles, TOML role configurations, an Astra orchestrator skill, project-level AGENTS.md instructions, and shell and PowerShell installers that copy the selected configuration into a target repository. The profiles set model, reasoning-effort, approval, sandbox, and concurrent-thread settings, while named role files can override the defaults. The repository also includes guides for orchestration patterns, plan-specific setup, iteration, and token-usage reporting from Codex session logs. It is licensed under Apache License 2.0.
Commerce Agents is Anthropic's reference implementation for building shopping agents for customers and merchant agents for back-office staff with Claude. It defines each agent through prompts, skills, tool contracts, grounding, memory, approval gates, and backend interfaces, and provides runnable examples for retail, travel, telecom, and entertainment. The shopping agent searches and compares products, plans purchases, fills carts, answers order and policy questions, and maintains customer memory. The merchant agent analyzes performance, manages listings and inventory alerts, handles pricing and promotions, and drafts campaigns; its writes are staged until a host approves them. The agents can run through the Anthropic Messages API, Claude Agent SDK, or Managed Agents, and the repository provides a Claude Code plugin for scaffolding or reviewing commerce agents.
Compositor is a free, open-source image editor for macOS built around Photoshop-style compositing and post-processing workflows. It uses layers and folders with blend modes, opacity, masks, clipping masks, adjustment layers, non-destructive transforms, selections, painting and retouching tools, content-aware fill, filters, and multiple project tabs. It imports JPEG, PNG, HEIC, and TIFF files, and exports JPEG images; Photoshop-style keyboard shortcuts are supported throughout. The repository provides an Xcode project and documents macOS 26 and Xcode 26 requirements. It is licensed under the MIT License.
CLM is an AI decision-making model and Python service that selects among candidate actions by embedding a state and each action separately, then scoring their alignment instead of generating a textual response. It is trained with bidirectional InfoNCE: matched state-action pairs are pulled together while incorrect or hard-negative actions are pushed apart. At deployment, cached state and action embeddings are scored with a projection head, enabling typed decisions such as binary judgments, choices, and ordered scores, as well as ranking candidate answers, tools, trajectories, or next moves. The repository provides CLM-8B through a TypeSafe-compatible HTTP API and a local Python engine. It runs a Qwen3-8B pooling encoder through vLLM, exposes endpoints including `/v1/systemone` and `/v1/rank`, and includes a browser playground, embedding and action caches, checkpoint hot-reloading, and scripts for fine-tuning projection heads on typed decisions or agent trajectories. The reference head can run on CPU or GPU, while the encoder is served separately; states longer than 2,048 tokens are truncated by default unless the limits are raised together. The project is released under the Apache 2.0 License, and the repository's CLM-8B weights are also released under Apache 2.0 on Hugging Face.
Coucou is an open-source desktop companion for Claude Code and other coding-agent sessions, appearing in the macOS notch or as a top-of-screen island on Windows. It displays session events such as files read, edits, and commands run; surfaces Claude Code permission requests for Allow/Deny approval; opens the relevant terminal on macOS; provides built-in Claude chat; and accepts dropped files as context. It can also attach a macOS window as Claude context and display optional integration pills for services including GitHub, Vercel, Notion, and others. On macOS, a hook script forwards Claude Code events over a Unix socket and waits for approval responses, while a borderless NSPanel and a SwiftUI Canvas render the animated Mochi character. The native Swift 6, SwiftUI, and AppKit application has no third-party dependencies. On Windows, a Tauri 2 application uses Rust, TypeScript, a transparent always-on-top window, Canvas 2D rendering, and a named pipe for hook events. The project states that it collects no telemetry, requires no account, and stores credentials in the macOS Keychain or Windows Credential Manager. Coucou is distributed from the project's releases and can also be built from source. The code is licensed under MIT; the Mochi name, character, icon, sounds, and media are separately reserved by the author. The Windows installer is temporarily unavailable according to the README because its unsigned build was flagged by Microsoft Defender.
disktree is a disk-usage treemap for finding and removing files and directories that occupy space, developed in Rust with GPUI. It scans a home directory, selected directory, mounted volume, or whole disk; draws nested blocks sized by actual disk usage; and supports navigation by size, file count, or age, filtering, hidden-file inclusion, apparent-size measurement, and classification of data such as caches, build output, media, and repositories. Users can mark items, review the complete selection, estimate the resulting free space, and move selections to trash or delete them permanently with confirmation and removal safeguards. The scan accounts for hardlinks, avoids following symlinks by default, and aggregates directory sizes in parallel. It runs on Linux, macOS, and Windows, with platform-specific disk-usage and trash behavior, and is licensed under the MIT License.
Dream Loop is an AI agent skill for building games, apps, and 3D scenes toward a visual target. It uses image generation to create a target screenshot, builds the scene—such as a Three.js scene in a browser—and has a separate vision-enabled critic compare the live screenshot with the target and provide feedback; the agent then iterates on the build and can optionally generate an improved target from the current state. Blender can be used for custom 3D modeling through Blender MCP or scripting. The skill can be installed with `npx skills add achimala/dream-loop` or cloned into an agent's skills directory, and requires an agent with image-generation access, vision input, and preferably subagents.
edge0 is an open-source streaming Mixture-of-Experts inference framework for running sparse MoE models on Apple Silicon Macs. Its MLX backend memory-maps expert weights from SSD storage and loads them on demand, so peak memory depends on the active experts rather than the model's total parameter count. A trained prerouter predicts the next expert routes so storage reads can overlap the forward pass, while Recover-LoRA adapters distill from the full-precision model to compensate for quantization loss; the base weights remain read-only and the adapters stay separate. The framework ships two end-to-end model tiers with bundled 4-bit checkpoints, LoRA adapters, and prerouter heads. It provides a command-line interface and Python API, supports demo, chat, and server modes, and exposes an OpenAI-compatible `/v1/chat/completions` endpoint. The current backend supports macOS on Apple Silicon M1 through M4; CUDA support is identified as planned. The repository is licensed under Apache-2.0.
fast-jev-compaction is an npm library and Claude Code plugin that compacts tool-call history without rewriting the original text. It pairs each tool call with its result, sends the conversation state and questions about each non-pinned call to Jev, and then keeps the call and result, keeps only the call while truncating the result, or removes both according to Jev's scores. Recent messages and the first message are pinned; state fitting progressively truncates inputs, abridges long text, collapses older messages, and reduces old tool calls to one-line records so requests fit within configured token estimates. User and assistant text is never removed or shortened in the returned transcript, and retained content stays verbatim. The package exposes compaction, decision, batching, state-fitting, and transport-building functions, while the Claude Code hook replaces built-in compaction and falls back to Claude Code's summary when Jev fails or reduction is insufficient. It uses the TypeSafe API by default and requires a TypeSafe API key.
Human Atlas is an open-source, browser-based interactive 3D anatomy explorer. It uses selectable BodyParts3D meshes to let users toggle anatomical system layers, search structures, and view exploded arrangements that show how body parts fit together. The video describes it as running locally as a static site without accounts or API keys.
Jevgrep is a command-line tool for coding agents that finds relevant files and source context in unfamiliar repositories from natural-language questions. It uses Jev to judge relevance across folders, files, and declarations, explores qualifying branches of the repository hierarchy, selects files through content previews, identifies useful source units and surrounding context, and returns a summary followed by file locations, reading leads, and verbatim excerpts with line references. Python and TypeScript/JavaScript support declaration parsing, while other text uses a fallback. It also includes an agent skill that teaches supported coding agents when to invoke the CLI and how to use its results. The CLI is distributed through npm as @dzhng/jevgrep, requires Node.js 22 or later on macOS or Linux, and requires authentication with a supported AI provider. Searches send eligible source content to Jev through the selected provider; local filtering excludes ignored, hidden, dependency/build, binary, and obvious credential files but is not a guarantee that sensitive data is removed. The project is MIT-licensed.
jev-trader is an AI market-making bot for the Kuru MON-USDC order book on Monad. A TypeSafe Jev model observes the order book once per block and predicts whether to buy or sell over a configurable future horizon; each block, the bot cancels its resting orders and submits a post-only limit order one tick inside the touch, aiming to earn the spread when a taker fills it. Its hot loop reads the book with one RPC call and submits the transaction with one asynchronous raw-transaction call, leaving receipt processing, fee estimates, and vault checks off the critical path. It records block decisions, quotes, fills, positions, and profit-and-loss data, and exposes snapshots, history, and server-sent events through a Bun server. If the model misses the block, it holds and posts nothing; position or margin limits can redirect a quote to the opposite side. The repository supports a dry-run mode with simulated fills and a mock momentum heuristic, or live Jev decisions using a TypeSafe AI API key and private key. It includes a deployed dry-run dashboard endpoint and can be run with Bun.
kev is an open-source, local Jev-inspired decision model from Jared Palmer. It runs on a laptop and accepts a document or other state plus typed questions, returning calibrated probabilities rather than generated text. It supports yes/no (noul), multiple-choice, and ordered-score questions. The model uses a LoRA adapter and a readout head on a Qwen base model. It packs the state and all questions into one sequence, applies a block-causal mask so each question can see the state but not sibling questions, and performs one prefill pass without decoding. A pointer head scores each option against the question's decision token and applies softmax; the head is trained with cross-entropy on labelled outcomes. The local server exposes a TypeSafe System One-compatible API at POST /v1/systemone, allowing the official TypeSafe SDK to connect by changing its base URL. It also provides model information, option-order permutation, and separate-pass comparison endpoints, plus a local playground. The repository includes 0.5B, 0.6B, 4B, and 8B model checkpoints and recipes for local or Modal-based training and evaluation. Serving is tested on Apple Silicon, with larger checkpoints requiring bf16 on a 32 GB Mac. The server has no authentication and is intended for local use. The project is licensed under Apache-2.0; base models and datasets have separate licenses.
Laya is an Apache-2.0 Python package and encoder-model decision engine developed by Convai Innovations. It accepts text or JSON state and evaluates typed questions in a single forward pass, returning categorical choices with probabilities and confidence, ordinal scores, or calibrated Boolean probabilities rather than generated text. Its stated uses include routing, ticket triage, prompt-injection detection, moderation, phishing detection, and churn-risk classification. Laya includes English, multilingual, and typed-decisions checkpoints, plus a router that selects a checkpoint using explicit settings, detected script, and best-effort language detection. The checkpoints use reinforcement learning against strictly proper scoring rules (RLCD); the project also provides fine-tuning and temperature-calibration workflows. The multilingual checkpoint is intended for more than 100 languages, while the repository cautions that the base models can perform near chance on some zero-shot typed-decision tasks and that large choice sets are constrained by the option-token budget.
M3E Canvas is a browser-based Material 3 Expressive design tool that turns interface sketches into prompts for AI coding tools. It provides drag-and-drop components, multiple phone and desktop screens, connected tap and swipe navigation, layers and groups, theme controls, previews, and PNG export. Designs can be converted into prompts in English, Japanese, Chinese, or Korean for Android or web targets, including behavior notes for individual components. An optional bring-your-own-key AI helper can draft behavior notes and screen descriptions by sending requests directly from the browser to OpenAI, Claude, Gemini, or DeepSeek. The app is a static Next.js export, saves work in browser localStorage, and is free and MIT-licensed.
magpie is a cross-platform menu-bar and command-line application for selecting models used by local coding agents. It detects configured agents, lets users change their provider, model, and related settings, edits only the changed keys in configuration files while preserving formatting, and saves profiles for switching groups of agent configurations. It also runs a local gateway at 127.0.0.1:3425 that exposes OpenAI Chat Completions, OpenAI Responses, Anthropic Messages, and Google Gemini-compatible endpoints. The gateway translates requests between these APIs, forwards them to configured vendors or local servers, and presents provider models through a shared provider/model catalog; signed-in Claude Code, Codex, and Copilot accounts can also be used as providers. A terminal UI, plain CLI, provider management, model-list refreshing, import links, and encrypted backup and restore are included. The application is distributed for macOS, Linux, and Windows, with a smaller terminal-only build, and is licensed under the MIT License. Its official homepage is usemagpie.ai and its source repository is maintained at yetone/magpie.
NanoJev is an open-source 0.6B parallel-decision model and training pipeline based on Qwen3-0.6B. It accepts states, questions, and candidate sets in a single forward pass and returns complete probability distributions without output-token decoding. Shared decision heads support dynamic-choice distributions over supplied candidates, Boolean proposition probabilities, and ordered score levels with expected values. The repository includes data generation, distribution-loss training, evaluation, persistent serving, and browser replay tools. Its game demonstrations combine model judgments with controller code: maze controllers ask local safety questions and track collisions and explored paths, while Snake controllers filter immediate collisions, plan toward visible food, and use the model to break ties between remaining actions. Checkpoints and datasets are distributed through Hugging Face, and the service exposes repeated batched evaluations through a local HTTP endpoint.
NiubiGEO is an open-source, self-hosted tool for tracking how AI models describe products and brands, which competitors they name, and which sources they cite. It accepts a domain, queries selected OpenRouter models with optional web search, and stores each model's original answer, descriptions, competitor associations, keywords, citations, ordinary URLs, errors, and execution conditions. Users can confirm model-derived competitors and keywords for follow-up tests that omit the target brand's name, repeat measurements, and schedule monitoring runs. Results are organized into separate projects for different domains and retain historical records so findings can be traced back to the underlying answers and evidence. The project states that it does not track traditional search-engine rankings and that offline and web-enabled tests should be interpreted separately. The Community Edition is free, open source, and licensed under Apache-2.0. It runs locally with Node.js 22 or later, requires an OpenRouter API key for testing, and can also be deployed with Docker; users pay the model, search-service, and hosting costs they incur. The project also offers paid AI testing by real people and GEO optimization services.
OpenMuse is a personal-agent application built by CopilotKit for iOS, Android, and web. It combines a persistent Chromium browser with an optional isolated Linux container, file and PDF handling, visible task plans, action reviews, and browser or terminal takeover so a person can inspect or continue the agent's work. It also provides Gmail and Google Calendar adapters with review required for sends and calendar changes. The application runs an API, durable task worker, and browser worker. Tasks use stored plans, progress, approvals, pauses, retries, and SQL leases; the browser worker maintains persistent Chromium profiles, while the optional non-root Linux container provides a retained workspace volume with bounded commands and no host-directory mounts or credentials. The interface is built with CopilotKit headless chat and AG-UI events, with inline email, browser, PDF, plan, and finance results. The repository describes OpenMuse as an alpha for self-hosting and building on, with model and Google-account configuration required for live agent and mail/calendar workflows. It is MIT licensed; CopilotKit Intelligence is a separate required service for rich conversation persistence and is not included under the repository's license.
Search is a small, fast WebKit browser for macOS developed by Office Commun. It provides a single address-and-search field, tabs, reading mode, picture-in-picture video, bookmarks, history, downloads, built-in ad and tracker blocking, per-site clutter hiding, and password storage in the macOS keychain. It has no account, sync, cloud storage, telemetry, or analytics; browsing data remains on the Mac. The browser uses WebKit and lazily creates each tab's web view, while its ad blocker runs as a compiled WKContentRuleList before network requests are made and its hidden-element rules are injected at document start. It can run Chrome extensions through WebKit's extension engine, adding shims for Chrome APIs that WebKit lacks; extension support requires macOS 15.4 or later. Search supports macOS 14 or later, is distributed as a free download of about 3 MB or through Homebrew, and is licensed under the MIT License. The repository contains a Swift and SwiftUI/AppKit implementation with no dependencies beyond Apple's macOS frameworks.
SemIf is an independent open-source tool, formerly called OpenJev, for making semantic if-statements with open language models. It accepts unstructured state, runtime-defined questions or criteria, and typed options, then reads the model’s option logits directly to return conditional probabilities without sampling an answer sentence, parsing JSON, or running a decoding loop. It supports direct, serial, and shared-state execution, prefilling common state to evaluate multiple criteria in parallel. Results and workflows include option scores, calibration, replay, benchmarks, verification, prompt hashes, model revisions, timings, and row-level outputs. It supports CUDA and CPU execution, Apple Silicon through MLX or PyTorch/MPS, and local GGUF models through llama.cpp. It includes an interactive browser WebGPU demo, reproducible fixtures, benchmark runners, and quality evaluations, and is released under the MIT License. SemIf is not affiliated with TypeSafe or Jev.
@shadcn/lint is an agent-first linter for Tailwind v4 design systems. It lets teams define component and theme rules that coding agents can verify through ESLint or Oxlint, reporting violations with suggested fixes drawn from existing components, variants, and theme values. Its rules include preventing component restyling, raw colors, arbitrary values, inline styles, unknown Tailwind classes, and dynamic classes the linter cannot read; custom contracts, messages, placeholders, component-import settings, and shared configuration are supported. It can be used with custom Tailwind components and does not require shadcn/ui. The package requires Node.js 20.19 or later, with ESLint 9.30 or later or Oxlint 1.80 or later, and is licensed under MIT.
SoL-Pi is an open-source standalone extension for the Pi coding agent, developed and maintained by NVIDIA. It packages four opt-in efficiency mechanisms: Action Fusion runs a follow-up validation command in the same edit or write call; ObservationPack replaces repeated large tool results with stable handles that support exact paged recall; the Evidence-Preserving Reducer condenses diagnostic logs into receipts only when retained quotations match archived source material; and Online Context Compact marks completed plan steps for Pi's native compaction when economic and context-window checks allow it. The extension operates through Pi's public APIs without patching or vendoring Pi, leaves the mechanisms disabled by default, and preserves original observations locally. It requires Node.js 22.19 or newer and is released under the MIT License.
Strata is a free, open-source local inference engine for running the 125-billion-parameter Qwen3.8-Flash-Next model on consumer Windows or Linux PCs. It distributes the model across the GPU, system RAM, processor, and, for some configurations, SSD storage; a mixture-of-experts design keeps frequently used experts on the graphics card while RAM and the processor handle the remainder, with speculative decoding to check batches of predicted tokens. It provides a browser chat interface, monitoring for model and hardware use, optional image input, and localhost APIs compatible with OpenAI, Anthropic, and OpenAI Responses clients for applications and coding agents. The installer selects an engine and model size based on available hardware, and the project supports NVIDIA and AMD graphics cards with at least 12 GB of VRAM, 32 GB or more of RAM, and Windows 10/11 or Linux. Strata is licensed under the MIT License; the included model and some components have separate licenses.
Universal Modder is an open-source toolkit by rehan-remade for AI coding agents that create offline, single-player mods for PC games. Its skills and tools identify a game's engine and existing modding route, inspect code and files, back up saves, build a working mod slice, generate art, 3D assets and audio through the fal MCP server, test the result in the running game, package it, and record findings for later agents. The repository supports Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode and other agents that read AGENTS.md, and includes the Python `um` CLI for game scanning, asset generation and processing, Windows automation, save management, video capture, publishing checks and a shared knowledge base of game-specific field notes. Its rules restrict use to games owned by the user and offline or single-player work; they prohibit online cheats, anti-cheat or DRM bypasses, and distributing game files or decompiled code. The repository is MIT licensed and requires Python 3.10+ and ffmpeg; Blender is used for 3D-to-sprite rendering.
Unreal Agent is an async-first agent harness from Unreal Labs. Its library and command-line executables coordinate persisted agent sessions, LLM turns, tool calls, and asynchronous operations. Inputs carry caller-supplied globally unique IDs for deduplication; sessions store append-only history that can be recovered or forked; and tool translators validate model-produced calls and convert them into serializable operations whose execution state is tracked separately. The harness includes a session inbox, coordinator, session store, context builder, LLM adapter, tool registry, tool translators, and an operation manager. Session and operation data are versioned and serializable, allowing operations to be dispatched to alternative or remote runtimes; unsupported session versions produce an explicit resume error. The repository contains the harness library, executables, and benchmark runners.
Vista.js is a React 19 framework for building applications with file-based routes under `app/`, React Server Components by default, and a single CLI for development, production builds, and serving. It supports regular React sites, file-based HTTP API routes, typed APIs through `vista/stack`, authentication scaffolding with middleware, and server-rendered or client-consumed interfaces. Its AI features provide generated agent files, model-provider configuration, tools, memory, streaming responses, and React hooks for agent interfaces. Its retrieval-augmented generation support can index documents in an in-memory vector store, retrieve relevant chunks through a tool, and pass them to an agent; keyword search is available when no embedding model is configured. The framework also includes a Rust-backed optional `flashpack` engine alongside its default webpack-backed engine, with `create-vista-app` used to scaffold projects.
Searchable transcript of GitHub Trending monthly #11（2026.09） — Github Awesome (14:03). Search for a phrase, then click its timestamp to jump straight to that moment in the video.
Captions sourced from the original video on YouTube, published by Github Awesome. The video, its captions and all related intellectual property remain the property of their respective owners; AINotes claims no ownership. Provided for research, accessibility and search — see the Transcript Notice and Copyright Policy.
00:00 These are 33 projects that caught developers attention in September. You'll recognize some from earlier episodes, but this time the month's biggest finds are all in one place. Let's get into it. Lia handles the small decisions that can slow an AI workflow down. Give it a support message and it can choose a department, score urgency, and estimate whether the customer might leave all in one model pass.
00:25 It returns typed answers instead of generating pros and its router selects a checkpoint for English or multilingual text. There are Python and TypeScript options for building it into an app. Jev Ultraast gives a browser agent a simpler job at each step. Pick an action and a numbered page element together. A small language model writes text only when the agent needs to type.
00:51 It reads visible controls instead of sending screenshots through the loop. then checks a target before clicking it. The repo's demo finds flights on Google Flights, though its speed results cover only a few test runs. M3 canvas lets you sketch an app before asking an AI coding tool to build it. Drag Material 3 buttons, cards, and navigation onto phone or desktop screens.
01:16 Link the screens, then tap through the flow in a preview. Change the colors and motion, add notes about what each control should do, and copy the whole design as a prompt for an Android or web app. Kev is for the little decisions an app makes all day. Which team gets a ticket, how urgent it is, or whether a person should step in. Its models answer choice, score, and yes or no questions with probabilities, so your code can pass uncertain cases to a human.
01:43 There are four sizes from a laptop friendly model to a larger GPU version. and you can fine-tune them on your own examples. Fast Jev compaction changes how clawed code makes room in a long session. Instead of rewriting the conversation into a summary, it asks Jev which old tool calls and results still matter. Stale ones are dropped or shortened. The text it keeps stays word for word, including your instructions.
02:13 It's also an npm library, and the plugin falls back to Claude Code's usual summary if pruning doesn't help enough. Compositor is a free open- source image editor for Mac built around a familiar Photoshop workflow. Stack layers, paint masks, adjust curves, retouch with healing or clone tools, and import PSD files while keeping many elements editable.
02:34 Its project format is simple enough for scripts and AI agents to build images, too. It currently requires an Apple Silicon Mac running Mac OS 26 or later. Lia MLX puts Lia's decision models on Apple silicon through MLX. Give it a piece of text and questions like which team handles this or does this need attention and it returns typed answers without generating a paragraph.
02:58 It runs locally on your Mac with no PyTorch or Cloud API in the inference path. A useful fit when an app needs quick decisions, not a chatbot. Strata brings a 125 billion parameter Quen model onto a gaming PC by spreading its work across the graphics card, RAM, and processor. Its setup picks a model size for your machine, then gives you a local chat page and an API that coding tools can connect to.
03:25 It runs on Windows or Linux, but gaming PC matters here. You'll need a supported GPU with at least 12 GB of VRAM and 32 GB of RAM. New GIO shows how AI models talk about your product, which competitors they mention, and what sources appear in their answers. Enter a domain, choose the models to test, then inspect the original responses instead of trusting a single visibility score.
03:52 You can also test keywords without naming your brand and repeat runs over time. It's self-hosted with your own model API costs. Semif turns open language models into semantic if statements. Give it some text and options like which support Q should handle a request and it reads probabilities for those options directly instead of generating an answer to parse.
04:15 It can reuse a shared document across several decisions and runs through CUDA, Apple silicon or a CPU backend. The repo includes its test inputs and results so you can inspect the claims. Magpie is one screen that sets the model for every coding agent on your machine. Now 32 of them from claude code and codeex to cursor and zed. Click an agent, pick a model and it edits that tools config without touching your comments.
04:44 Its local gateway insulates between open AI and anthropic and Gemini APIs so one provider key can serve every agent. Routing groups let several models from different providers act as one. Human Atlas is an interactive 3D anatomy browser that runs in the browser. Spin the 3D body, hide entire systems, then click a bone or organ to see it on its own. There's even an exploded view that pulls the parts apart so you can see how they fit together.
05:12 It's built on 3JS, batching the geometry and driving visibility and selection from GPU textures so the orbit stays smooth across 2.3 million triangles. Open Muse is a personal AI agent that shows its work while it gets things done. Give it a task and you can follow its plan, watch the browser, or take control yourself. It can work with files and PDFs and pause for your approval before sending an email or changing a calendar event.
05:41 Tasks can pick up after interruptions, so you can come back to the result. So, PI is an NVIDIA Labs extension for the PI coding agent that cuts token use without cutting the work. It adds four opt-in tricks. It fuses an edit and its validation into one call. Turns big repeated outputs into handles you can page back through. Compacts diagnostic logs while keeping the quoted source and marks finished plan steps for compaction between turns.
06:12 Claude Commerce Agents is a blueprint for building two kinds of shopping assistant. One helps customers search, compare, and fill a cart. The other helps staff spot inventory issues, update listings, and plan promotions. The repo includes runnable demos for retail, travel, telecom, and tickets. Purchases stay with the store's checkout, and a person approves every merchant change before it goes live.
06:38 Shad CN lint catches a problem. Regular code checks miss. An AI generated page can work perfectly and still ignore your design system. Set rules for your Tailwind components, and it flags things like rogue colors, arbitrary spacing, or a button with padding it shouldn't have. The error tells the coding agent what to use instead. It works with React, Vue, and Smevelt.
07:02 Jev Trader is a crypto trading bot built around a tight deadline, roughly 300 milliseconds per monad block. It reads Kuru's Mon USDC order book, decides which side to quote, and replaces its previous limit order. A live dashboard shows decisions, fills, gas costs, and profit or loss. By default, it dry runs on real market data with a mock model, so you can inspect the behavior before enabling live trades.
07:28 CLM is built for the moment and AI agent has to choose what to do next. Give it the current situation and a set of possible actions and it scores the options instead of writing a long answer. It can reuse cached representations of familiar actions to make repeated decisions faster. The repo includes an 8B model, an API, and a playground where you can try it yourself.
07:53 Code notch pins a small black notch to any edge of your Mac screen and shows how much of each coding assistance usage limit you've burned. Each tool gets a ring that fills as you go, covering clawed code, cursor, codeex, copilit, and about a dozen more, and it mostly borrows credentials from tools you already have installed. The notch opens and chimes when a session finishes or needs you.
08:18 Cuckoo turns your Mac notch into a little control desk for coding agents. Complete with an animated companion named Moi. Watch Claude code edit files, open the live diff, and answer permission requests without hunting for the right terminal. Mochi reacts when a session finishes, too. On Windows and Linux, the companion lives at the top of the screen instead.
08:41 NanoJV puts a small AI model on fast decisions. Turn, wait, fire, or choose another move. Give it a state and possible actions, and it returns probabilities for each choice without generating an answer token by token. The same 0.6b model is tested across snake, mazes, and two vdoom tasks. The repo includes its checkpoint, training data, and browser replays.
09:02 You can inspect. Vista.js gives React developers a familiar place to start. Folders become routes, server components are the default, and one CLI handles development and builds. From there, you can add typed APIs, scaffold authentication, or build a streaming AI agent beside your app. It also includes tools for searching your own documents. There's a default Webpack engine and an optional Rustbacked one.
09:29 Edge Zero tackles a memory problem, running large mixture of experts models on everyday devices. It keeps expert weights on an SSD and loads the ones needed for each step. A predictor starts fetching the next set early, while adapters help recover quality lost to 4-bit compression. The project provides 8B and 35B model releases with engines for Mac, Windows, iOS, and Android.
09:56 Search is a small Mac browser that keeps the page front and center. It uses the WebKit engine already on your Mac with tabs, split view, and a single field for addresses or searches. Reading mode clears away page clutter, and you can permanently hide a site's cookie banner or newsletter popup. Your history, bookmarks, and passwords stay on your Mac.
10:19 Agent memory helps coding agents remember decisions after a session ends. It keeps those memories as plain markdown files that Claude Code and Codeex can share. Agents search a local index, open only the details they need, and trace a memory back to the original conversation. A separate cleanup pass can combine old notes, but deleting one requires your approval.
10:43 Disc tree answers the question every full disc leaves you with. What's taking up all that space? It draws your files as a mosaic with bigger tiles for bigger folders. Zoom in, spot old caches or build output, and mark what you want to remove while the free space estimate updates. You review the full list before committing with trash as the default where available.
11:06 Unreal agent is a go framework for agents whose tool work may keep running after a model turn ends. It records session history, translates tool calls into operations, and dispatches those operations asynchronously. If a process is interrupted, the stored session and operation state support recovery. You can fork a session or swap out components like the model adapter and operation manager to fit your setup.
11:33 Jev Grep is for the moment you know what code does, but have no idea where it lives. Ask a repository a plain English question, and it returns likely files, source excerpts, and line references your coding agent can inspect. It works through folders and declarations to find useful leads. That makes it handy when a behavior spans unfamiliar files and you don't know which symbol to search for.
11:58 Nimble is an open 9B model for decisions you can express as choices or yes or no checks. Give it text and a schema and it returns a typed answer with probabilities in one scoring step. Its training recipe uses pairs of examples where one crucial fact changes the correct answer, teaching the model what to pay attention to. The repo shares the model data and code to run it locally.
12:24 Universal modder gives coding agents a playbook for modding PC games you own. It helps identify the game engine, choose a modding route, back up saves, build a working piece, and test it in the game. Its tools can also generate sprites, 3D assets, sound, and showcase videos. The repo includes examples for Terraria, Age of Empires 2, and Minecraft inside GTA 5.
12:44 Codex Astra Luna Orchestrator gives Codeex agents defined roles for bigger coding tasks. Choose a profile and a lead agent can delegate exploration, research, implementation, and testing to Luna sub aents. A separate reviewer checks the work before the lead integrates it. The repo includes readymade configurations and installers for Windows, Mac, and Linux, so you can add the setup to an existing project.
13:13 Dream Loop gives an AI coding agent a visual target before it starts building. It generates a dream screenshot for a game app or scene, builds toward it, then captures the real result. A separate AI critic compares the two and points out what needs work. The agent keeps improving the build and can even generate a more ambitious target for the next round.
13:37 Open Glean gives your notes, files, saved web pages, and connected apps one place to search. Ask a question and it searches your Hydra database, streams an answer, and cites the sources it used. For bigger questions, Deep Research splits the work into smaller searches and shows its progress. You can choose which collections to search and bring your own model for answers.