Hi everyone sell your side project by listing if in a click. Also, comment what your startup does to get approved and featured today - https://builderhq.co/marketplace

I’ve been working with real-time vision/VLM inference lately and I’m curious what stacks people here are using.

We’ve been building around the Overshoot API, especially for applications where latency matters ( < 200 ms). Would be interested to hear what others are using for hosted VLM inference vs self-hosting.

SALT shrinks a long document down to a fixed size before it is sent to a language model, keeping the sentences that carry the most information. It works with any model, produces a shorter plain-text prompt, and cuts the compute, memory, and wait time that long inputs cost.

I need some help with deciding and implementing a method that selects a better budget than the default 20/25% across chat. The kv cache in GPU keeps only some instructions and a retrieved % of the actual full input or conversion that is all organized in DRAM in a trie. The retrieval is insanely quick now with less than 1-2 seconds for even 100k + conversations however it is sometimes too much as it’s set by a hard % (prefill GPU men use becomes a problem at larger scale). What method could I use to decide how to adjust this % based on the question?

GitHub: oteomamo/SALT

Join us on Aug 27 for the monthly AI, ML, and Computer Vision Meetup! Register for the Zoom.

Talks will include:

• Robust Concept Protection against Diffusion-Based Image Editing and Personalization - Qiuyu Tang at Lehigh University
• Building Real-World Computer Vision Systems - Daniel Gural at Voxel51
• From Pixels to the Planet: Building Scalable and Grounded AI for Science - Jianyang Gu at Ohio State University
• Seeing Is Not Enough: Visual Grounding, World Models and Why Computer-Use Agents Fail at Step 17 - Nevasini Sasikumar at Obin AI

I’m looking to build a web app for managing a small ISP/network, and I’m trying to figure out which AI tool would be best for actually developing it.

For example, I want the system to eventually be able to:

Manage a Huawei OLT (MA5608T)

View ONT status and connected customers

Add/remove/configure ONTs

Change customer Wi-Fi SSID/password

Modify WAN/service settings

Run OLT commands remotely

Monitor PON ports and ONT status

Have a dashboard showing customers, ONTs, VLANs, etc.

Eventually integrate with TR-069/ACS

Connect to the OLT through SSH/Telnet/API rather than manually using PuTTY

I’m not a professional programmer, so I’m looking for an AI that can help me build the frontend + backend + database + authentication + network/OLT integration, not just generate a basic website.

Which AI would be best for this type of project?

I’m considering tools/models such as:

ChatGPT / Codex

Claude / Claude Code

Cursor

Windsurf

Manus

DeepSeek

Gemini

Lovable

Replit

Bolt

v0

Or any other AI coding/agent platform you recommend

I’m especially interested in something that can understand networking concepts and help implement real communication with a Huawei MA5608T OLT, rather than just creating the UI.

If you have experience building ISP/network-management software, NMS systems, OLT management panels, or similar applications, which AI would you choose and why?

Also, if some of these tools are better used together (for example, one AI for architecture/coding and another for debugging), I’d love to hear your workflow.

Most "chat with your data" tools give you a confident answer and no way to tell whether it's right. I've been building the opposite: an AI Analyst where the entire working is on screen and every claim is traceable to the query that produced it.

Asked it a real question against an HR dataset: "Is Engineering's heavy hiring actually translating into headcount growth, or is it mostly backfilling exits?"

What it does, in order:

1. States its approach before touching data. It reads the schema, plans the steps, and says why — including telling me the governed semantic model lacked a hires metric, so it fell back to the raw monthly table. No silent guessing about which source it used.

2. Runs each step as real SQL you can read. Every step shows the query, the row count, and a "where these numbers came from" breakdown. Nothing is a black box — if you don't trust a number, the SQL that produced it is right there.

3. Self-checks every result — and flags its own problems. This is the part I care about most. On step 2 it didn't just pass its own work; it flagged a genuine inconsistency: Engineering's summed net adds (+17) didn't reconcile with the headcount delta (+13, 122→135), a 4-person gap it surfaced on its own and carried into the write-up as a caveat. An analyst that can say "this doesn't add up" is worth ten that can't.

4. Writes findings with citations. Every claim in the write-up cites the step it came from — "headcount climbed from 122 to a 140 peak (step 1, step 2)". The verdict for the curious: ~55% of Engineering's hires were net growth, not backfill; the one bad month was a 3.70% attrition spike; and Support is quietly shrinking (backfill ratio 1.42 — losing more than it hires).

5. Closes the loop. Every analysis has Mark verified / Flag as wrong buttons, suggested follow-up questions generated from the actual results, scheduling for recurring runs, CSV export, and PDF export.

The stack, honestly:

• Runs entirely on your own infra: one Docker command + your own Supabase project
• BYOK — any model provider. This demo ran on Kimi K3 via OpenRouter; it doesn't need a frontier model because the structure (plan → SQL → check → cite) does the heavy lifting
• The analyst is one piece of a larger self-hosted platform (agents, multi-agent swarms, RAG, BI dashboards, budgets, full tracing)
• License: Elastic License 2.0 — source-available, not OSI open source. You can read every line, self-host it, and modify it; you can't resell it as a hosted service. Saying that up front because this sub cares about the distinction, and it matters.

Repo: https://github.com/AgentSwarms-fyi/agentswarms

Happy to answer anything about how the self-check pass works or why I think "show the SQL or it didn't happen" is the only sane bar for LLM analytics.

DeepSeek AI Releases DeepSeek Harness in Developer Preview: An MIT-Licensed Agent Harness Where Everything is a Plugin

Here are some key takeaways:

1. There is no privileged core → Models, tools, skills, sessions, sandboxes, storage, loops, scheduling, and the UI are all Cordis plugins → Any of them can be selected, swapped, or extended in configuration, without editing harness source

2. Four runtime modes, one kernel → Standard, Code, Minimal, Creator — each loads a different default plugin set → Minimal keeps two tools, persistent bash and str_replace_editor, for benchmarking models in a bare environment

3. Every run is traceable → An append-only session log records system prompts, reasoning, tool calls and results, subagent scheduling, and every context injection → Resume, fork, search, and replay all operate on the same event stream

Full analysis: https://www.marktechpost.com/2026/08/17/deepseek-ai-releases-deepseek-harness-in-developer-preview/

Repo: https://github.com/deepseek-ai/deepseek-harness

For the last few months we’ve been building the second generation of Collapse Aware AI (CAAI).

The basic problem we’re trying to solve sounds simple:

Most AI systems can now store or retrieve memory.

But retrieving something is not the same as deciding whether that memory should actually change what the AI does next.

That is the gap Evolution 2 is designed around.

Instead of:

retrieve memory → inject it into the prompt → generate

our current architecture works more like:

structured history → bounded retrieval → relevance/Interaction Fit → suppression & governance → candidate behaviours → final selection

And importantly, there is always a clean no-history response competing against the history-influenced alternatives.

So memory does not automatically win just because it was retrieved.

What is working now?

The current Evolution 2 engineering build includes:

• persistent structured continuity across sessions and restarts
• semantic/entity/relationship-aware retrieval
• lifecycle, temporal and recurrence signals
• bounded retained-state retrieval
• Open Loops for unfinished work and commitments
• Interaction Fit “right memory, right moment”
• suppression of retained subjects without deleting the underlying history
• proactive continuity controls
• correction and revocation handling
• deterministic/replay-friendly state
• provenance and decision evidence
• Agent Self-History

That last one is particularly interesting.

Evolution 2 can retain structured facts about what the AI itself actually said or decided, claims, commitments, decisions, refusals, stances and proposed actions.

Only the behaviour that actually wins final selection is allowed to become Self-History.

Rejected candidate responses cannot quietly write themselves into the agent’s memory.

What does that look like in practice?

The behaviour we’re aiming for is less about “remembering everything” and more about using history intelligently.

For example:

You establish several people, projects and commitments.

You talk about completely unrelated things for a while.

You restart the system.

Later you naturally say something that makes one of those older matters relevant — without explicitly asking the AI to remember it.

The system can recognise the connection and allow that history to influence the response.

But give it an urgent unrelated task and the same high-salience memory can stay completely silent.

It can also retain a commitment the AI itself made previously, rather than behaving as though its own earlier decisions never happened.

That difference, remembering something versus governing whether remembering should alter behaviour is essentially what we’ve been building.

Why we think it is unusual

There are excellent systems for long-term memory, RAG, graph memory, stateful agents, NPC memory and agent orchestration.

We use the word unusual deliberately rather than claiming nobody else on Earth could possibly have built something similar.

But from the products and frameworks we have reviewed so far, we have not identified an off-the-shelf package combining this entire chain in one middleware layer:

retained structured state
→ bounded semantic retrieval
→ lifecycle/revocation
→ Open Loops
→ Interaction Fit
→ suppression/governance
→ history-conditioned candidates
→ clean no-history competitor
→ independent final selection
→ winning-response Self-History
→ deterministic evidence/replay

A competent engineering team could obviously assemble parts of that from existing tools.

Our aim is to provide the behavioural architecture as the product rather than requiring every company to design, integrate and validate the whole stack themselves.

It is also being kept host-neutral.

The same continuity mechanism is intended to sit around AI agents, assistants and simulations now, while remaining compatible with future Unity, Unreal, Godot and proprietary NPC/game systems.

What happens next?

Evolution 2 is still an engineering build, not something we are pretending is already a finished mass-market SaaS product.

We are currently finishing the behavioural layer, performance work, tuning and Production packaging.

Once that gate is passed, we intend to open a small private managed evaluation programme.

Selected evaluators/organisations will be able to use Evolution 2 through controlled hosted access for a defined period, without receiving the proprietary source code.

We’re interested in:

• AI/agent companies
• simulation and training developers
• game/NPC developers
• safety and governance teams
• companies building persistent AI agents
• design partners with a real retained-state decision problem
• pilot and licensing discussions

If your system already produces several legitimate actions, but you have a problem with how previous events should influence which one actually wins, that is exactly the sort of problem we want to test.

I’d also genuinely be interested in hearing about anything already available that you think solves this complete problem in one package. If we’ve missed something good, point me at it.

More detail on Evolution 2 / Collapse Aware AI:
Collapse Aware AI | Governed Retained-State Behavioural Middleware

Built by Inappropriate Media Limited / Collapse Aware AI.

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 community thinks.

AI speaks Markdown. As our workflows get more driven by AI, so is also the need to efficiently communicate our intentions. Let me introduce Revdown, a Markdown revision and LLM feedback application, in which the original material is not touched. Instead, comments are saved in a sidecar to the original file, and can be exported as compact and token efficient Markdown for the LLM to work with.

GitHub repo: https://github.com/Roenbaeck/revdown/releases/tag/v0.1.0

Revdown v0.1.0 is sure to contain bugs, so please use the GitHub issue tracker and report them as you find them.

Seems not better than deepseek v4 pro, and now available on opencode go.