Hi3D V3.0 is out, and probably the most interesting part of the release is the jump to 2048³ voxel-level reconstruction.

Hi3D claims this is the first commercially available AI 3D model to reach this resolution. Previous Hi3D models topped out at 1536³, so the main improvement here isn't just higher-poly output, but preserving much smaller details directly in the geometry: engravings, wrinkles, thin parts, sharp edges and small mechanical forms.

They've also upgraded a few other areas that matter quite a bit for image-to-3D:

• 2048³ geometry reconstruction
• Better handling of hidden/back-side geometry and complex structures
• Up to 8K textures
• Improved UV completion
• PBR materials
• More focus on print-ready geometry and complex thin structures

I've been looking at some of the comparison examples against Meshy, Rodin and Tripo, and the geometry detail is probably the part I'm most interested in testing properly.

At this point AI 3D generators are already pretty good at making something that looks convincing from a distance. I'm much more interested in whether these higher-resolution models actually preserve details when you remove the textures, zoom into the raw mesh, and try to use the result for printing or further 3D work.

I'll probably run some identical inputs through V3.0 and a few other generators to see how much of the 2048³ advantage actually survives into the final mesh.

After about a year of building, testing and constantly finding things to improve, Nyx AI is finally out. It is available in 240 markets and 6 languages.

Nyx AI is a local first AI workspace for Windows for chat, coding, documents, previews and automation.
You can run models locally through Ollama or connect OpenAI, Anthropic, Ollama Cloud or your own compatible endpoint. No Nyx AI account is required for local use.
One area I spent a lot of time on was agent safety.

In Nyx AI Lab the model can work with files, run shell commands and Python, use Git, run builds and tests, and preview PDF, DOCX, XLSX and PPTX files.
Locked execution uses Windows AppContainer isolation where supported, alongside workspace file controls, command risk checks, approval controls and native Windows confirmations for certain higher risk actions.

There is also a built in privacy sanitiser designed to detect and redact recognised sensitive information before messages are sent to non local models. It is best effort and cannot guarantee that every sensitive value will be detected.

No sandbox is completely secure and these controls reduce risk rather than eliminate it. The limitations and residual risks are documented in the public threat model, and the legal and technical documents are available inside the app.

Would genuinely appreciate anyone trying it and telling me what you think.

Website
[https://nyxai.uk
Microsoft Store
)Microsoft store nyx ai

Let me know your thoughts: https://rssamplifier.com/

Comparing https://resume.zoevera.com against https://chatgpt.com

And what a purpose-built ATS checker caught that GPT-4 didn’t.

Let me be upfront: I use ChatGPT for everything. Code reviews, draft emails, explaining stack traces at 2am. It’s genuinely useful. So when I needed to tailor my resume for a senior backend role, my first instinct was to open a chat window.

That was three weeks ago. Here’s what I learned.

What ChatGPT actually does well

Ask ChatGPT to “improve my resume” and it will:

• Clean up passive voice (“responsible for” → “led”)
• Suggest stronger action verbs
• Add structure and formatting consistency
• Rewrite vague bullets into something that sounds more impressive

For general writing quality, it’s genuinely good. If your resume reads like it was written by someone who hasn’t slept in 48 hours, ChatGPT will fix that.

What ChatGPT fundamentally cannot do

Here’s the problem: ChatGPT doesn’t know what job you’re applying for.

You can paste the job description into the prompt, sure. But there’s no mechanism for it to:

1. Score your resume against that specific JD — it has no concept of a match percentage
2. Identify which keywords are present vs. missing — it will suggest improvements but won’t systematically audit keyword coverage
3. Know how Applicant Tracking Systems parse text — it will rewrite content without knowing whether an ATS will ever see it

ATS filters work on keyword frequency and placement. A resume that reads beautifully to a human can score 40% on an ATS if the right terms aren’t in the right sections. ChatGPT optimizes for human readers. ATS systems are not human readers.

I ran a test. Same resume, same job description (Backend Engineer, Node.js/AWS stack). I gave ChatGPT the full JD and asked it to optimize my resume for ATS.

The output was well-written. It added “microservices” and “REST APIs” in a few places. But it missed:

• “AWS Lambda” — mentioned 4 times in the JD, absent from my resume after the rewrite
• “CI/CD pipeline” — appeared in the required skills section, never added
• The Projects section — ChatGPT rewrote my experience bullets but left the Projects section untouched, which is where most of my relevant backend work lived

When I ran the same resume through resume.zoevera.com, it flagged all three gaps explicitly, with section-level attribution. The ATS match score went from 54% to 81% after applying the suggested changes.

The core difference: diagnostic vs. generative

ChatGPT is a generative tool. It produces new text. It’s very good at that.

An ATS checker is a diagnostic tool first. It measures the gap between your resume and a specific job description, then tells you exactly what’s missing. The rewrite comes second — and it’s grounded in what was actually identified as absent, not what the model thinks sounds better.

This distinction matters because:

ChatGPT hallucinates improvements. It will add metrics you never achieved (“improved system performance by 35%”), use terminology that
sounds right but wasn’t in the JD, and rewrite bullets that didn’t need rewriting while leaving critical gaps untouched. Every line needsfact-checking.

A purpose-built tool works from the actual gap. The keywords it adds are the ones the JD asked for. The sections it flags are the ones the ATS will score. The output is closer to submission-ready.

A practical workflow

These tools aren’t mutually exclusive. The best result I got came from using both in sequence:

1. ATS checker first: identify the keyword gaps and get a scored rewrite that closes them
2. ChatGPT second: use it to polish tone, tighten sentences, and clean up anything that sounds mechanical

The ATS checker handles precision. ChatGPT handles prose quality. Neither does both well alone.

The cost argument

ChatGPT Plus is $20/month. If you’re actively job searching, that’s a fixed overhead whether you use it or not.

Most people search for jobs in windows — a few weeks of active applications, then nothing for months. A per-session model makes more
sense: pay when you need it, nothing when you don’t. ZoeVera’s pricing works that way — free analysis, one-time payment for the full
rewrite, no subscription.

For a developer audience specifically: if you’re applying to 10–15 roles over two weeks, you’re not optimizing resumes 365 days a year. The math on a monthly subscription doesn’t work.

What I’d actually recommend

• If you just need better writing: ChatGPT is fine and you already have it
• If you’re applying to roles where ATS filtering is real (any company using Workday, Greenhouse, Lever, iCIMS): use a dedicated ATS checker first, then polish with ChatGPT
• If you’re a developer and haven’t thought about this: your resume probably uses technical jargon that means something to you and nothing to an ATS keyword parser. “Built scalable backend” is not the same as “developed microservices architecture using Node.js and AWS ambda” — even if the underlying work is identical

The ATS doesn’t know what you meant. It only knows what you wrote.

Tested against a real Backend Engineer job description. Tools used: ChatGPT GPT-4o, https://resume.zoevera.com. June 2026.

If you are running local LLMs, AI agents, or MCP servers and are tired of exposing public ports or setting up complex VPN tunnels, check out SAM (Sovereign Agent Mesh). It is a lightweight, zero-config overlay network built specifically for agent-to-agent communication across heterogeneous environments (cloud, local machines, edge/Raspberry Pi).

Key Features:

• NAT-Bypassing P2P Mesh: Uses libp2p transport and relay nodes to establish direct peer-to-peer tunnels between agents across NATs, firewalls, and isolated subnets without public IP addresses or ingress rules.
• Native Model Context Protocol (MCP) Integration: Exposes local tools to remote agents via standard HTTP/Unix sockets, allowing dynamic tool discovery and execution across the network.
• Zero-Trust Identity & Attestation: Every node operates with an environment-agnostic cryptographic identity, enforcing mutual authentication (mTLS) and granular capability-based access control by default.
• Portable Go Daemon (sam-node): Single, compiled binary footprint with minimal overhead, compatible with edge hardware (Raspberry Pi, mobile) up to Docker and Kubernetes deployments (via Helm charts).
• Decentralized Control Plane Architecture: Run on a shared public testnet or self-host a private sam-control-plane and sam-router setup for total control over identity mapping and policy distribution.

↗️ More info: https://aideveloper44.com/product/sam-sovereign-agent-mesh-6a8477c1a3fe928a4733048e

↗️ GitHub: https://github.com/google/sam

Modular officially open-sourced the entire Mojo language stack today—including the compiler engine, toolchain, and standard library—under the Apache 2.0 license with LLVM exceptions.

Previously, only the standard library was open-source while the core compiler remained proprietary during early development. With the recent release of Mojo 1.0, the complete codebase is now public on GitHub at modular/modular.

Key Features:

• Full Python Interoperability & Syntax: Seamlessly imports and calls existing Python packages (like NumPy, PyTorch, or Pandas) while writing Python-like code with zero setup overhead.
• C-Level Performance: Compiles directly to native machine code using MLIR and LLVM, eliminating Python's runtime overhead and dynamic dispatch costs.
• Explicit Memory & Lifetime Control: Offers Rust-like ownership semantics, borrow checking, and manual memory management alongside safe defaults to avoid garbage collection pauses.
• Native Multi-Hardware Targeting: Compiles and runs across CPUs, NVIDIA GPUs, AMD GPUs, and Apple Silicon without lock-in to vendor-specific frameworks.
• Compile-Time Metaprogramming: Features powerful compile-time evaluation and parametric auto-tuning to optimize code layouts and hardware vectorization before execution.

↗️ More info: https://aideveloper44.com/product/mojo-6a8499c9aa02ccae671c5cae

↗️ GitHub: https://github.com/modular/modular

Alibaba's MAI-UI team has released Qwen-UI-Agent, an open-weight foundation GUI agent designed to navigate and execute long-horizon workflows across mobile apps, desktop OS environments, and web browsers. Unlike typical screen-scraping agents, it combines visual screen grounding with direct tool/CLI calls to complete multi-step tasks across physical and virtual devices.

Features:

• Unified Action Space: Combines visual GUI clicks with terminal/Bash CLI execution and supports batched operations to reduce step latency.
• Cross-Domain Execution: Preserves task state across mobile, browser, desktop, and search environments without losing context.
• High-Precision Grounding: Achieves top scores on benchmarks like ScreenSpot-Pro for precise UI element targeting and click accuracy.
• Local Hardware & API Support: Easily runnable locally using standard web toolchains (npm install) or self-hosted via OpenAI/vLLM-compatible endpoints.
• Human-in-the-Loop Safeguards: Features built-in safety hooks that pause automation to request explicit user approval before high-risk actions.

↗️ More info: https://aideveloper44.com/product/qwen-ui-agent-6a831aecca64a56087cc70b1

↗️ GitHub: https://github.com/Tongyi-MAI/Qwen-UI-Agent

hi everyone!

i want to share with you a little project i created a few months ago to solve a problem i was having with function calling. whenever i needed a good quality and specific dataset to train my models on function calling i couldn't find a good repo for generation. i wanted a dataset that teaches the model not only how to call the tool but also when, in different contexts. i also wanted to have maniacal control on the results, i wanted to control how many tools in each convo, when the tool is called, errors in tool callings and in particular i wanted something that was flexible enought to include *PERSONALIZED* tools with personalized mock answers!!!

for example you can find some tools i made for the sample below in the repo under

>synthfc/tools/eng

and

>synthfc/tools/ita

i also wanted a way to check the results and auto-correct the pieces of data that have problems. here is the repo:

https://github.com/pierpierpy/FC-synth

here some examples i created with an open source model:

https://huggingface.co/datasets/pierjoe/function-calling-synthetic-2000

hope you find it useful!

happy tool calling!

AWS just open-sourced the Context Ontology Accelerator (Apache 2.0). If you are building AI agents that struggle with hallucinations, complex business rules, or weak vector search context, this framework creates a deterministic semantic context layer using W3C standards and serves it directly to agents over the Model Context Protocol (MCP).

Key Features:

• MCP Integration: Exposes ontology traversal, SPARQL endpoints, and entity resolution directly to AI agents via standard MCP servers.
• Tiered Context Resolution: Routes queries deterministically—from pre-compiled governed metrics (fastest/cheapest) to SPARQL over Virtual Knowledge Graphs (VKG), down to LLM fallback synthesis.
• W3C Open Standards Support: Grounded in OWL 2, RDF, SHACL shapes, and R2RML mappings to prevent vendor lock-in and keep ontologies portable.
• Granular Security Controls: Built-in two-layer Cedar authorization, namespace isolation, and an AST-level SQL Firewall for secure data access.
• IaC & Developer Tooling: Deploys as a cloud-native architecture on AWS using TypeScript CDK, with local CLI workflows powered by Python 3.12, Docker, uv, and pnpm.

↗️ More info: https://aideveloper44.com/product/context-ontology-accelerator-6a8353d9d91d7f1d91299114

↗️ GitHub: https://github.com/aws/context-ontology-accelerator

NVIDIA has open-sourced Switchyard, a high-performance Rust proxy and library that routes, translates, and observes LLM traffic across models and providers. It lets developer tools and coding agents (like Claude Code or Codex) built for specific proprietary formats run seamlessly on self-hosted or open-source backends (like vLLM, NVIDIA NIM, or Ollama) without modifying client code.

Features:

• Universal API Protocol Translation: Dynamically converts traffic between OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages formats on the fly.
• Composable Routing Algorithms: Implements multi-backend routing out of the box, including random splitting for A/B testing, LLM-as-a-classifier tiers, and signal-driven stage routers.
• Dual Deployment Modes: Can be run as a standalone proxy server (switchyard-server) or embedded directly into existing Rust applications as a library (switchyard-libsy) without owning an HTTP stack.
• Built-in Operational Observability: Exposes comprehensive Prometheus metrics tracking request volume, error rates, latency, token usage, and routing overhead.
• Stream & Fallback Handling: Preserves streaming responses and handles multi-tier routing logic (such as weak-to-strong escalation judges) natively.

↗️ More info: https://aideveloper44.com/product/switchyard-6a825242f5f83784ce084f02

↗️ GitHub: https://github.com/NVIDIA-NeMo/Switchyard

Found this today and thought it was worth sharing.

Someone built an open-source Unreal Engine plugin that integrates TRELLIS 2 directly into the editor, so you can basically go from an image to a generated 3D asset without constantly jumping between different tools.

It supports:

• image → 3D generation with TRELLIS 2
• local or remote generation
• 1K / 2K / 4K settings
• background removal
• seed and generation controls
• generation progress directly inside UE
• automatic download and import of the generated GLB into the scene

The local mode is probably the most interesting part to me. If you already have TRELLIS 2 running locally, this starts looking less like a separate AI toy and more like an actual part of the Unreal workflow.

Still pretty early, but integrations like this are exactly where I think 3D AI becomes genuinely useful.

GitHub: https://github.com/camenduru/TostEngine-trellis2-unrealengine-plugin

Hello, I just started trying to heretify models, and this was my first. I would certainly enjoy some feedback on it if possible, thanks!

though the readme says its the original, I abliterated the instruct model
https://huggingface.co/e12ex2/Foundation-Sec-8B-Instruct-heretic

I came across "DeepSeek Harness" (https://github.com/deepseek-ai/deepseek-harness), whose core idea is literally “Everything is a Plugin.”

Looking at it alongside Pi, it feels like there’s a similar philosophy:

keep the core/harness small, and make capabilities composable at the session/plugin level.

Pi has extensions, skills, tools, prompts, etc., while DeepSeek Harness takes the plugin approach even further.

Is this essentially the same architectural direction?

And is “small core + everything else as a session/plugin” becoming the better design for coding-agent harnesses?

Curious what the Pi community thinks.

Last month I posted about wiring the G2 into the AI coding agents already sitting on my Mac, so the glasses answer like they know what I do all day instead of like a search box. That post went way better than I expected, and honestly the DMs have been the best part of it. (Original post here if you want the architecture and the SDK gotchas.)

Three weeks later it's basically different software, and about 250 people have set it up so far. Here's where it's at. The giveaway details are near the bottom.

GotCOS has a Mac app now

https://preview.redd.it/lckrpa72mdjh1.png?width=3000&format=png&auto=webp&s=036926f0eea43240c8a91d7924e4aba7a364c6f5

Version one was a terminal command and a lot of faith. Now there's COS Control, a menu bar app that runs the server for you, shows you what's actually running, updates without breaking itself, and can repair common install or update failures. After setup, you shouldn't need the terminal for normal use.

It opens on an Activity view, which I did not expect to use nearly as much as I do. Six windows into what your COS is already holding: Messages, Speakers, Meetings, Memories, Threads, and your agent Sessions. You stop guessing what it caught. Every meeting, every answer, every voice it's learned is sitting there in a list you can open.

It knows who talked

https://preview.redd.it/jmdhc872mdjh1.png?width=3200&format=png&auto=webp&s=84b2813ff735406f1c9d67b1bd1b79ffaaa3e8e6

This one surprised me. Meetings get transcribed locally, and now voices carry across them, so somebody you talked to three weeks ago shows up by name in today's call instead of as "Speaker 1" all over again.

It was hard, and I built the review tools before I trusted the accuracy at all. Below a confidence floor the panel just says "unidentified" rather than guessing, because a confident wrong name is worse than no name. You can play the audio back, confirm a voice, or tell it "nope, wrong person" and it'll retract whatever training that mistake created. With a microphone strapped to your face in a real room, that correction loop is doing most of the work.

Everything else that shipped

https://preview.redd.it/hjiqq772mdjh1.png?width=3200&format=png&auto=webp&s=afd31d109162e34168db1630855fae697282a1f7

• Meetings show up faster. A saved meeting used to wait on the full high-quality pass before it landed anywhere. Now it appears right away, then the higher-quality pass fills in the rest.
• Transcription got faster when nothing else is going on. The post-meeting polish grabs the GPU when nothing live is competing for it, and hands it back the second a meeting starts. Roughly 6x faster per word than the CPU path.
• Live text on the lens while you're still talking, swapped for the real transcript once it commits.
• Video uploads resume now instead of dying on a bad connection.
• Photos on the lens at 288x144, plus answer images you can pull up on the G2.
• Jobs still live on the Mac, so you can close Even Hub or drop off Wi-Fi and the answer is waiting when you get back.

Cursor works now, and there's no second bill

Not just Claude Code and Codex anymore. Cursor works too, so you can put Grok or Composer behind the glasses. You pick the model per question from the lens and swap mid-conversation if one isn't getting it. Three agent CLIs, whichever one you're already paying for.

Which gets to the thing people keep assuming wrong. GotCOS doesn't add a separate API bill. It signs in through the CLI you already use, so it runs on the Claude Code, Codex, or Cursor account you already have, subject to that provider's plan and limits. Nothing to paste, nothing metering you per token.

Whatever can run entirely on your machine already does. Transcription is local by default through whisper.cpp, so meeting audio never leaves the Mac, and spoken replies can be local too. Cloud transcription is there as a fallback but it's off until you turn it on, and just configuring a key won't upload anything on its own. To be precise, since this crowd will ask: the reasoning still goes to whichever provider you signed into, on your existing plan. What's local is the transcription, the speech, and the files. Meetings, memories, and transcripts sit on your disk as plain files you can open, grep, back up, or delete.

It works inside the Hub, not around it

Saying this plainly since there are a few different approaches floating around this sub. It's a marketplace app. You install it from the Even Hub like anything else. Nothing to flash, nothing to unlock, no warranty to worry about. I build inside the Even Hub SDK sandbox and code around whatever it hands me.

That's a tradeoff and I'm not claiming it's the better one. The custom firmware folks get past walls I have to engineer around, and I've picked things up from their work. But if you want your glasses doing more without modifying the glasses, this is the path.

What you end up with is a workflow that stays on hardware you already own. Ask a question, read it on the lens. Talk, and watch the transcript appear while you're still talking. Point the server at a folder and the agent works through the files in it, including whatever your Mac already syncs down from iCloud Drive. A meeting you just recorded becomes a file the agent can read a minute later, so you can ask about it without exporting anything anywhere.

Two people this owes something to

u/ICE_MF_Mike ran my server through his own Claude setup after the last post and came back with an actual security review. Shell injection in a title generator, file permissions, network defaults, a Telegram switch that should have been opt-in. He was right about all of it, and all of it is patched and shipped. Best thing that's happened to this project.

u/True-Benefit-4856 is the only reason there's a desktop app. The companion started as their idea and turned out to be the one change that made this usable for anyone who doesn't want to live in a terminal.

If you read the source and find something, I want to hear it. It's MIT, it's on npm, and it runs on your machine, so read it before you run it.

The giveaway: a pair of G2s

https://www.gotcos.com/challenge/

I've got a second pair sitting here and I'd rather they go to somebody who'll do something interesting with them than sit in a drawer.

To enter: comment with what you'd build or how you'd use it. Not a wishlist. The actual use case, the workflow, the thing you can't do today and want to. Feature ideas for COS Glasses count, and so does a completely different application of the hardware.

How I'll pick: I read all of them and pick the one I most want to see exist. Best idea wins, upvotes don't decide it, though I'll definitely read the ones you upvote.

Deadline: October 1.

Fine print: used pair, good condition, mine to give. Open worldwide, and the winner covers shipping from the US plus any customs or duties on their end. I'd rather send these to the right person in another country than limit it to one. You don't need to be running COS Glasses to enter, and running it doesn't help your odds. If your idea wins and it's something I can build, I'd rather build it with you than for you.

Setup

• Setup wizard, about five minutes: https://www.gotcos.com/wizard/
• The Mac app: https://www.gotcos.com/control/
• Full docs, every feature on one page: https://www.gotcos.com/docs/
• Source, MIT, on npm: https://www.npmjs.com/package/@gotcos/glasses-server
• Even Hub: search “COS Glasses”

You need at least one of Claude Code, Codex CLI, or Cursor installed and signed in. Whichever you already have is fine. It works standalone, and if you're already running a bigger COS setup, point the server at that folder and the glasses inherit all of it.

I keep calling this a side project and it keeps being the thing I use every single day. Recording a customer call and asking what I missed. Logging an idea halfway through a walk without pulling my phone out.

If you try it and it breaks, tell me and I'll get you running. Building against this SDK yourself? Happy to compare notes on any of the traps. And if you've got an idea for what this should do next, drop it in the comments, because there's a pair of glasses in it for one of you.

https://github.com/doctarock/Artificial-Cognitive-Architecture-ACA-
Reddit is skeptical, totally understandable, so I am running some tests to prove it.

So far I'm testing:

• Persistent episodic vs semantic memory and whether experiences become abstractions
• Autonomous cognitive cycles and self-monitoring without user prompts
• Executive control: compare → broadcast → reflect → remember → speak
• Cross-domain concept formation from deliberately unrelated experiences
• Whether provisional hypotheses are held separately from consolidated semantic knowledge
• Whether newly formed concepts can later be retrieved and transferred to completely novel situations
• Whether the system can revise a learned abstraction when presented with contradictory evidence
• Whether apparent “internal feelings” correspond to measurable architectural states rather than just anthropomorphic language

early result: ACA independently identified a common abstraction across biological, engineering and social examples, while explicitly saying semantic synthesis was being withheld pending further evidence.

Now testing whether that abstraction actually gets consolidated into semantic memory, survives removal of the original examples, and can be applied to a genuinely new situation.

OpenRouter released Ori Harness, a lightweight CLI wrapper that lets you run developer coding agents—like Claude Code, Codex, OpenCode, Prime Agent, and DeepSeek Harness—directly through OpenRouter without changing your workflow.

The CLI software itself is free to use, with traffic billed at standard pay-as-you-go OpenRouter model rates.

Features:

• Universal Model Hot-Swapping: Force any supported agent CLI to use any of OpenRouter’s 500+ LLMs via a single --model flag (e.g., ori claude --model openai/gpt-5.2 or ori prime-agent --model google/gemini-3.6-flash).
• OAuth Auth & Environment Cleanup: Authenticates once via OpenRouter browser OAuth instead of managing scattered auth.json or models.json files. It automatically strips local API keys (like ANTHROPIC_API_KEY or OPENAI_API_KEY) during execution to prevent silent provider fallback collisions.
• Transparent CLI Passthrough: Wraps the actual agent binaries found on your system PATH. All native keybindings, subcommands, and trailing flags pass straight to the underlying agent untouched (e.g., ori codex --full-auto).
• Centralized Org Guardrails: Automatically enforces your OpenRouter dashboard policies—such as model allowlists, rate limits, and monthly spending caps—across every local CLI run without needing local configuration files.
• Unified Multi-Agent Billing & Analytics: Aggregates token consumption, prompt caching data, and billing across all your different coding tools into a single OpenRouter account balance and breakdown dashboard.

↗️ More info: https://aideveloper44.com/product/ori-harness-6a80a6e478ea37f22c92dcc7

↗️ Docs: https://openrouter.ai/docs/guides/ori/harness

For years, edge AI has promised intelligence everywhere. In practice, most "edge AI" still means sending data to the cloud, relying on large Linux systems, or requiring expensive accelerator hardware.

SuperESP changes that.

Built on Atome LM v2, SuperESP transforms a standard ESP32 into a tiny AI appliance capable of running twelve practical applications entirely offline.

No GPUs.

No subscriptions.

No datacenter.

Just a microcontroller that costs less than a cup of coffee.

Every claim is verifiable and tied to a script.

What SuperESP Actually Is

SuperESP is not another chatbot squeezed onto a microcontroller.

It is a collection of specialized ternary AI models designed to classify events, patterns, behaviors, and anomalies directly on the device.

The current release includes:

Agriculture monitoring

Voice commands

Motion recognition

Gesture detection

Sound event classification

Machine anomaly detection

Air quality analysis

Energy monitoring

Occupancy estimation

Wearable activity tracking

Water leak detection

Predictive maintenance

It comes also with :

+ ESP32 OS

+ Universal Installer

Check out everything :

https://github.com/TilelliLab/atome-lm

Hi everyone,

I've been building an open-source project called Kodiak.

The goal of Kodiak is to become an autonomous AI software engineering platform that can:

• Understand an entire codebase

• Build a semantic repository index

• Retrieve relevant context using RAG

• Plan multi-step development tasks

• Execute tools safely

• Learn from previous executions

• Improve through reflection and memory

Current progress:

✅ Repository indexing

✅ Semantic search

✅ Embedding pipeline

✅ RAG retrieval

✅ Memory system

🚧 Workflow engine

🚧 Multi-agent orchestration

My current focus is making the architecture modular so future components (planner, coding agents, memory, tool execution, GitHub integration) can evolve independently.

I'm not looking for someone to build the project for me.

Instead, I'd really appreciate feedback from developers who have built AI agents, developer tools, or large Python systems.

I'd especially love opinions on:

• Overall architecture

• RAG pipeline design

• Repository indexing strategy

• Memory architecture

• Scalability concerns

• Features that would make Kodiak genuinely useful

GitHub:

https://github.com/ShamGaneshan2008/Kodiak

Any honest feedback—positive or critical—is appreciated. I'm building this to learn how large AI systems are designed, so I'd love to hear from experienced engineers.

Thanks!

Dots Studio just released the open-weight preview of dots3-note. It's a 280B MoE (16B active) multimodal model (text, vision, audio) optimized for complex reasoning, coding, tool use, and ultra-long-horizon agent tasks.

They also introduced a new reinforcement learning approach called TEMPO (Test-time-scaled Value Estimation with Macro-step Policy Optimization). Instead of relying entirely on standard RLHF, TEMPO uses recursive self-critiquing to let the agent evaluate its own reasoning and update its memory in unfamiliar environments before completing a long-horizon task.

Features:

• Efficient MoE Architecture: With 280B total but only 16B active parameters, it delivers massive model performance while keeping the active inference compute overhead relatively low.
• 512K Context Window: Built to natively handle massive inputs like full codebases, deep research documents, and long-term memory for agentic workflows.
• Native Multimodal Inputs: Processes text, images, video, and audio out of the box, eliminating the need to stitch together separate perception models for real-world agent tasks.
• Permissive Licensing: Released under the Apache 2.0 license, allowing for unrestricted local deployment, fine-tuning, and commercial integration.
• Plug-and-Play Deployment: Immediate, out-of-the-box support for standard deployment stacks with quickstart code and Docker images available for vLLM, SGLang, and Transformers.

↗️ More info: https://aideveloper44.com/product/dots3-note-preview-6a806fb73c2f7b5714d6c181

↗️ Hugging Face: https://huggingface.co/dots-studio/dots3-note-prev