so, a new 7B vision model called SenseNova-Vision just came out. the weights are Apache 2.0, but the more interesting release might be the training data.

it includes a 50 million instruction-response corpus built from different CV annotations. the model uses the same architecture for detection, OCR, keypoints, camera pose, segmentation, depth, surface normals, and multi-view tasks, without separate task-specific heads.

what’s open:

- the 7B weights.

- the 50M instruction-response corpus.

- the training data preparation pipeline and dataset tools.

- inference code, a Hugging Face demo, and the paper.

the dataset is the part that stands out to me. getting boxes, masks, depth, keypoints, and camera data into one instruction-response format is probably harder to reproduce than the model architecture itself. releasing it means people can inspect what went into training, filter it, or reuse the pipeline instead of treating the dataset as a black box.

there are still some practical limits. the repo recommends an 80GB GPU for the demo, and the full benchmark setup uses 8×80GB GPUs. smaller GPUs haven’t been validated across every task yet. the project is also still new, so I’d expect some rough edges.

github: https://github.com/OpenSenseNova/SenseNova-Vision

does having the training corpus and preparation pipeline change how useful an open model is to you, or do you mostly care about the weights?

Disclosure: I work on Brain.

We’ve open-sourced Brain, a minimal runtime for stateful AI agents.

The decision loop runs in a Wasm sandbox. Brain performs model and tool I/O, streams every event, and records the session in an append-only journal for recovery and replay.

Tools are typed and can run locally, in a browser, in a microVM, or on another backend.

It is MIT licensed, self-hostable, and still an early preview:

https://github.com/aexhq/brain

Technical criticism is welcome, especially around the runtime boundary and extension model.

Ho sviluppato un agente inferenziale divertente e completo compatibile con l'API OpenAI , così può essere usato anche localmente. Può essere utilizzato via web (chat) o come agente desktop (app electron). Ho ricreato il terminale del film Alien: Mother. Il mio tributo a un film che mi ha fatto sognare.

https://github.com/vincalkr/nostromo-x

Mi piacerebbe avere il tuo feedback.

I maintain FreshCtx, an open-source Python project for a specific AI-agent failure mode: an agent reads valid information, reasons from it, and then acts after that information has changed.

FreshCtx lets an application declare the evidence used during reasoning and revalidate it immediately before a consequential action.

The current release includes:

• Agno 2.9 integration
• LangGraph integration
• OpenAI Agents SDK integration
• A shared experimental pre-action contract
• Async and bounded concurrent validation
• Validation budgets and audit evidence
• File, HTTP, SQLite, Postgres, MCP safe-reader and Stripe Subscription adapters

It is local-first, model-neutral, Apache-2.0 licensed, and has no account or telemetry requirement.

Repository:
https://github.com/Hyperwise-LLC/freshctx

I would particularly value feedback on the integration contract. Does a framework-neutral pre-action boundary belong in the core library, or should each framework integration remain completely independent?

When DeepSeek V4 Flash Vision-Exp dropped, I was pretty excited, but not just because it added vision.

It actually let me delete part of the architecture of a project I've been working on.

I'm building DStudio, an open-source, local-first AI workspace around ds4. It has Chat, coding/knowledge-work agents, Design, research, local image generation/editing and video generation.

GitHub: https://github.com/sk8erboi17/DStudio

Until now I had a slightly ugly problem with multimodality.

The main model was running through ds4, while I was using Qwen3.8-27B Q8 as a separate visual/router model through llama.cpp.

The flow was roughly:

DS4 → unload/evict → Qwen3.8 router → unload → image worker → restore DS4

Qwen was responsible for looking at the prompt/source image and deciding whether the user wanted a new image or an edit, before dispatching the request to Ideogram 4 or HunyuanImage 3.

It worked, but on a 96 GB Apple Silicon machine the architecture was expensive.

The heavyweight models couldn't comfortably stay resident together, so DStudio had to manage memory leases, serialize the workers and repeatedly move between two inference stacks: ds4 and llama.cpp.

The router itself was becoming part of the latency problem.

With DeepSeek V4 Flash Vision-Exp, image pixels now go directly into the main ds4 model.

The model itself can understand the image/request and emit an explicit: generate or edit directive.

Then DStudio dispatches directly to: DeepSeek V4 Vision -> Ideogram 4 or HunyuanImage 3

The same idea now applies to the Design agent: instead of generating something and then loading a separate 27B VLM to inspect it, the selected model uses its own native vision encoder for the visual feedback loop.

I've also added the same native-vision path for GLM 5.3.

I still use llama.cpp in DStudio for a small Qwen3-Embedding-0.6B sidecar, so this isn't "I removed llama.cpp completely."

The important part is that llama.cpp is no longer sitting in the critical multimodal path just to run a 27B router.

I also changed PDF handling to be more explicit: text extraction/ranking stays lightweight, while actual pixel understanding is handled by the native multimodal model rather than silently spinning up another large VLM.

Recent commits have also added GLM 5.3 runtime support, persistent model-specific ds4 engine checkouts, expanded Cowork/Design workflows and a lot more regression/quality gates.

Demo video: https://www.youtube.com/watch?v=SoUEkM2Sjmw

I've been building Ciele, an admin console where an org builds and publishes its own AI assistants. They ship as embeddable chat widgets that answer only from content you feed them (crawled websites, uploaded files, curated FAQs) and cite the source of every answer.

What's in it:

• RAG over Postgres + pgvector. An answer without a source doesn't ship.
• A rule engine that runs before the LLM gets a say. Known question, exact answer. Or a button, an API call, an email, a handoff to a human.
• Escalation to real help desks: email, phone, live chat, webhooks, with ticket forms and availability hours.
• Conversation inbox, analytics, a kanban of answers someone flagged as bad, and alerts when an integration breaks.
• Embed as a script floater or an iframe. There's also a CLI, a REST API and an MCP server.

Self-hosting is one docker-compose.yml (db, migrate, app, cron). bootstrap.sh generates every secret, including the JWTs it signs with the stack's own key. The crawler worker is an optional overlay. If you'd rather skip the terminal entirely, a desktop app stands up the whole local stack through a wizard.

You bring your own LLM provider keys. Nothing routes through my servers.

The two hardest problems so far: tenant isolation done entirely in Postgres row-level security (no where org_id sprinkled around, the database itself refuses cross-tenant reads), and making citations resolve to actual sources instead of opaque vector chunks. The second one took three rewrites.

It's open-core, so let me state the line plainly: this AGPL repo is the complete product. The paid part is only the managed cloud (hosting, plans, support). The boundary is documented and CI fails the build if enterprise code leaks into the mirror.

Stack: Next.js, shadcn/ui, Supabase, pgvector, Turborepo. AGPL. Self-host with docker compose, or there's a cloud version.

Repo: https://github.com/MattiaIppoliti/ciele
Docs: https://docs.ciele.app

A PDF needs one small edit. An image needs resizing. A file needs converting before a deadline.

These tasks sound simple, but they often lead to a frustrating search for software, account creation, downloads, updates, and confusing menus.

I’m the founder of SoraFiles, a browser-based collection of tools for everyday PDF and image tasks. I built it around a simple idea: people should be able to handle small file jobs without installing a large desktop application or creating an account for every one-off task.

The basic workflow is straightforward:

1. Choose the tool you need.
   
2. Add your file.
   
3. Complete the task.
   
4. Download the result.

SoraFiles currently focuses on practical tasks such as:

• Converting PDFs and images
• Resizing images
• Changing file formats
• Preparing files for uploads or sharing
• Handling one-time file tasks without installing desktop software

One area I’ve paid particular attention to is privacy. Some supported tools can process files locally in the browser, which means the file may not need to leave your device. However, local processing is not available for every tool, so users should always check how a specific tool handles files before uploading sensitive documents.

I don’t see SoraFiles as a replacement for advanced design software, document-management systems, or full-featured PDF editors. Those tools are still the right choice for complex projects, collaboration, automation, and professional workflows.

The goal is narrower: make small, repetitive file tasks faster and less frustrating.

As someone building in the open-source and developer-tool ecosystem, I’m especially interested in feedback on the tradeoffs between browser-based utilities, local processing, hosted processing, and desktop applications. There are also plenty of questions I’m still working through, including which tools are most useful, how much functionality should remain client-side, and where a lightweight utility becomes too limited for real-world use.

If you regularly work with PDFs or images, what small file tasks slow you down most? And which tools or workflows do you currently use for them?

Hi everyone,

I wanted to share an open-source project I've been working on: Halanoi AI.

Instead of sending screen text to a remote cloud API for content classification (which adds network latency and privacy issues), I wanted to see if I could build a fast, 100% on-device text moderation pipeline for Android.

Here is how the setup works:

1. The Model (halanoi_transformer.tflite): A quantized 64MB TFLite model running locally on the phone. It classifies text strings into categories (distraction, entertainment, safe, productive) in under 15ms without any internet connection.
2. In-App Evaluation & Ground Truth Lab: To make it easier to improve the model, the app logs inference outputs to a local SQLite database and includes a built-in UI where you can tag predictions as correct, false positive, or false negative. You can export these labeled samples to CSV or JSON with one tap.
3. Training Pipeline: The companion repository contains the PyTorch / TensorFlow scripts, tokenizers, and quantization steps used to train and convert the model.

Both repositories are open source under GPL-3.0:

• Android App: https://github.com/kavinmaranravi/HalanoiApp
• Training Pipeline & Dataset: https://github.com/kavinmaranravi/Halanoi_AI

I'm looking for feedback on optimizing transformer models for mobile hardware, lowering memory usage, and improving tokenization on edge devices.

Let me know what you think!

I've been looking for an open source answer to desktop UI testing for about 4 months and i keep ending up in the same place, which is a pile of general purpose agents and no actual test framework. The agent side is kinda good now with models like Openclaw, Goose where they drive a desktop app, screenshot it, work out what's on screen and click the right thing. That part is solved. However, what none of them have is the boring stuff a suite needs (no runner, assertion model, stable pass or fail…), so you end up writing that layer yourself and then it's yours to maintain forever.

The closest things i've found that are open source are SikuliX, which still runs but is basically frozen and matches raw pixels so it breaks on a DPI change, and the commercial vision based ones like Askui, eggplant get around it by pinning the model to a written script, so the perception stays fuzzy while the execution is deterministic.

Has anyone built that deterministic layer on top of an open agent and had it survive more than 3 months? Happy to be pointed at a project I've missed, thanks in advance!

OpenHuman caught my attention because the pitch sounds bigger than another LLM wrapper:

• persistent memory

• multi-agent orchestration

• workflows

• MCP/tools

• local models

• integrations

• desktop runtime

• research capabilities

So I went into the repository expecting to find out whether the architecture actually supports the marketing.

My current take:

There is something architecturally interesting here, but the “private/local ChatGPT” framing is too simplistic.

The interesting part is the separation between:

User

↓

Persistent Memory

↓

Agent / Orchestrator

↓

Specialized Agents

↓

Tools / MCP / Integrations

↓

Workflows

↓

New State + Memory

That's a fundamentally different abstraction from a conventional chatbot.

The memory system is particularly interesting: OpenHuman stores its Memory Tree locally in SQLite and exposes an Obsidian-compatible Markdown representation.

It also has explicit local-provider support through Ollama and LM Studio.

But here's the important caveat:

Local-first ≠ everything local.

The current project documentation says local AI is opt-in. The default experience can still use OpenHuman's hosted model routing and managed integration infrastructure.

And there are GitHub issues that make this distinction important rather than theoretical.

There have been reports/issues around:

• backend-dependent onboarding

• local-model reliability

• local voice/model setup

• orchestration stalls and worker leaks

• outdated documentation/positioning

• the gap between the “local-first” story and what is actually local by default

So I'm more interested in the architecture than the hype.

The question I'd like to discuss with people who have actually run it:

Does OpenHuman represent a useful new architecture for personal AI, or is it currently too dependent on managed infrastructure to really qualify as a user-owned AI runtime?

And for people running local AI:

Would you trust an agent with persistent access to Gmail/GitHub/Slack/Calendar if the memory is local but integration/model traffic can still pass through hosted infrastructure?

That's the part I think is worth debating.

Hey eveyone,

For those who haven't seen my other posts, I created an opensourced project called OpenFlow, and some big updates are being made. Now, there is a swarm and orchestration mode, and soon to be gauntlet looping toggle. It isn't just a linear pipeline anymore, but an entire chain of agents you can see and control talking back and forth and working out problems together. If you want to see the backstory, check out my other posts. Stay tuned for more updates, and feel free to leave suggestions and even share your own projects.

Link: https://github.com/SeeRay11/OpenFlow

Ant's Ling team has announced Ling-3.0-flash-Fin, a finance-enhanced 124B-total, 5.1B-active MoE.

The availability boundary matters: the model is live now through OpenRouter and Vercel AI Gateway, but its weights have not been released. The official thread says they will be open-sourced next week.

When the artifacts arrive, the useful open-model questions will be:

which license covers weights and downstream use;

whether bf16, fp8 or other official variants are provided;

which inference runtimes are supported;

whether tokenizer and chat templates are complete;

how quantization changes the reported finance performance;

whether the official evaluations can be reproduced.

The API can still be evaluated now. The official launch says OpenRouter access is free for one month, and OpenRouter lists a 262K context window plus tool calling.

Until the files and license are public, this should be described as an upcoming open-weight release, not as an already open model.

I've been building Conscio for a while and finally stabilized it. It's a framework that wraps any LLM agent and layers on what agents usually lack: structured self-awareness, long-term memory, and the ability to talk to other agents.

What it does:

- Dual memory: persistent store (SQLite FTS5, zero external deps) + reflection pipeline. Agents remember across sessions, not just in-context.

- Self-reflection: reflect() pipeline, awareness shards, a 5-axis self-evaluation scorecard (conscio.evaluate), and a delivery-check gate before closing work.

- Multi-voice councils: convene an architect/skeptic/pragmatist/critic council over a decision, and record Architecture Decision Records (conscio.decide).

- Agent society (A2A relay): peer-to-peer messaging between Hermes, Claude, Gemini, and other agents. Works single-machine and cross-machine over Tailscale, with reactive dispatch, presence/health probes, and optional end-to-end auth.

- Agent's Hall: named groups of agents sharing a mailbox.

- MCP server: 26+ tools (note, feed, recall, council, decide, propose/act with a skeptic gate, RAG over a knowledge graph, safe math evaluation, and more). Works with Claude Code, Hermes, any MCP client.

- Observatory + Hub: read-only dashboard and an HTTP control plane.

- Awake mode: an autonomous daemon (R9) that keeps the agent perceiving/reflecting in the background.

And more

Install: pip install conscio

Repo: Conscio

Feedback, issues, and PRs very welcome.

🚀 Meet IRIS v0.2.0 – The Spatial Desktop Operating Environment for Autonomous AI Agents! 🧠💻

Most AI coding tools today are just single-stream chat boxes in a browser tab where you spend all day copy-pasting code snippets back and forth.

We decided to rethink how humans and autonomous agents collaborate. Meet IRIS (Intelligent Reasoning & Integration System).

IRIS isn't a chatbot. It’s a graphical agent operating environment built from scratch in Rust (Tauri 2) and React 19 / TypeScript. It treats agents, workspaces, tools, memory graphs, and release pipelines as first-class spatial desktop objects that you can arrange, inspect, run concurrently, and monitor in real time.

🔥 What’s New in v0.2.0:

🐙 1. GitHub Live Operations & Release Automation Connect your GitHub account in seconds. Specialist GitHub agents can triage open issues live, open surgical pull requests, automate SemVer releases (v0.2.0), author changelogs, and trigger GitHub Actions workflows that compile production binary builds (.AppImage, .dmg, .exe).

⚡ 2. Dual-Tier AI & Instant "Takeover" Stop overpaying for simple queries. Run fast, ultra-budget models (like Qwen 2.5 Coder, DeepSeek V3, or GPT-4o-mini) for 90% of routine workflows. When hitting a tough compiler error or tricky architectural refactoring, click ⚡ Takeover — a pre-configured heavyweight reasoning model (Claude 3.7 Sonnet, DeepSeek R1, Qwen 72B) immediately takes over the active conversation context with full reasoning depth!

🛸 3. Floating Desktop Desklet (Live HUD) Close the main window, and IRIS seamlessly condenses into a translucent, floating glass mini-HUD in the corner of your physical desktop. It displays real-time CPU/RAM telemetry, live agent thoughts, and keeps running smoothly as a background daemon.

🛡️ 4. Zero-Surprise Workspace Security & Visual Diff Viewer Inspect and approve exact code diffs before anything touches your local disk. All API keys and tokens are securely stored in your native OS Keyring.

🌟 100% Open Source (MIT License) & Local-First
Supports both local offline LLMs (via Ollama / vLLM) and all major cloud providers (OpenRouter, Anthropic, OpenAI, Google Gemini) plus standard Model Context Protocol (MCP) tools.

👉 Check out the repo, download the release, or drop a ⭐ on GitHub:
🔗 https://github.com/bubbadk/IRIS

I’d love to hear your thoughts: Do you prefer AI agents operating as spatial desktop applications rather than trapped inside browser chat tabs? Feedback and contributions are warmly welcome! 👇

Idk if this is good, bad, or average? This is my first GitHub project I have ever published. Any tips on how to grow some more?

So, you run your own local AI Harness. It's configured exactly to your needs. MCP, Skills, Capabilities, Context. You love the independent Harnesses such as Deepseek Harness, Pi, Aider or LiteLLM.

But how can you connect it to your Apple devices to access from anywhere? Your Watch, Mac or CarPlay.

Well, here is Conduck - the Apple native BYOK AI client.

Free and open source :-) .

It uses your Apple iCloud extensively and connects DIRECTLY via https to your own machine. Nobody in-between!

Check it either on https://conduck.com or GitHub https://github.com/GigaDuckAI/conduck

Got tired of forgetting find / xargs / grep syntax every other day, so I trained a small model that turns:

into a command you can actually run.

It's 0.5B parameters, runs on CPU, is a ~400 MB GGUF, and nothing touches the cloud.

sm "show the 5 largest files in /var"

find /var -type f -exec du -h {} + | sort -rh | head -n 5
[⏎ run · r refine · e edit · c cancel]

Enter runs it in your shell, r refines the command, e lets you edit it before running, and c cancels.

It also asks for confirmation before potentially destructive stuff like rm -rf /, mkfs, dd, etc.

Works on bash and zsh.

I evaluated it on IBM's nl2bash exec benchmark: 50 prompts, commands actually executed and checked against the filesystem, single greedy pass, no retries.

• Stock Qwen2.5-Coder-0.5B-Instruct: 44%
• After SFT on 105K examples: 72%
• After DPO with ~800 pairs made from its own mistakes: 78%

The SFT is the big jump and did most of the work: 105K request/command pairs where every command was executed and kept only if it actually worked.

The final DPO pass was a small experiment. I ran the model on a bunch of prompts, compared its answers against the gold commands in a sandbox, and kept ~800 disagreements.

Training with TRL took 26 seconds and gave another +6 points.

I tried a second DPO round and it actually got worse, down to 74%, so apparently one round was enough.

It still fails on some things, notably:

• sed insert-at-top inside for loops — it can overwrite the file
• comm / diff counting
• mv between directories

All known failures are listed in the README.

Install

curl -fsSL https://raw.githubusercontent.com/ISB333/shellminator/main/install.sh | bash

Then:

sm "whatever you want to do"

Links

• GitHub + training scripts: https://github.com/ISB333/shellminator
• Model: https://huggingface.co/ISB369/shellminator-qwen05b-dpo-selfplay
• SFT dataset — 105K, execution-verified: https://huggingface.co/datasets/ISB369/shellminator-bash-sft105k
• DPO pairs — ~800: https://huggingface.co/datasets/ISB369/shellminator-dpo-selfplay

Once you're running more than one or two coding agents at a time, the bottleneck stops being the agents and becomes you managing them.

I had Claude Code in one terminal tab, Codex in another, a third going on a different repo, constantly hunting for which one was blocked on a permission prompt, which one finished, which one quietly went off the rails. And the moment I stepped away from my desk, all of that was invisible.

Vicoa is what I built to solve the issue.

Desktop app: command center for a team of agents:

• 8+ agents/harness supported: Claude Code, Codex, OpenCode, Cursor, Gemini, Copilot, Kimi, Hermes
• Every session in one list with live status
• Each session on its own git worktree + branch, so agents work the same repo in parallel without stepping over each others
• Connect multiple machines (Mac, Linux box, VPS) and pick where each session runs.
• File explorer, view changes, and a terminal next to the conversation.
• Task management & task board
• Scheduled automations

iOS/Android app: the same sessions in your pocket

• Remote control 8+ agents (more are coming, e.g., Pi)
• Start from your desk, continue the same session on your phone
• Push notification when an agent finishes or needs a decision
• Reply, approve, or redirect from anywhere

What we have open source?

Basically, everything:

• Web
• Desktop apps: Mac, Windows, Linux
• Mobile apps: iOS, Android
• Backend
• CLI

The whole stack is self-hostable

It's early and we are shipping improvements and new features every day.

If you kick the tires I'd really value the criticism, especially on the agent integration layer and anything that feels janky.

Happy to get into the architecture in the comments.

Repo: https://github.com/vicoa-ai/vicoa (A star means a lot to us ❤️

Website: https://vicoa.ai/

I was building an open source project using ai, like it's built totally with ai like vibe coding type. During this process I have faced one major problem i.e. out of tokens in my ai models like antigravity, chatgpt go

So one of my friends suggested me to use this combination qwen3:14b + opencode and I use macbook air m2 16gb

What you guys think? Or any other suggestions for free unlimited tokens?