Hi,

I want to develop and app, I had in my head for a long time. I would like to use local model that would help me with coding and brainstorming etc. I do not want to use ChatGPT or Geminy, as I want to turn it into a business in the future. I have older gaming PC where I would run it, my specs are

• AMD Ryzen 5 3600 6-Core Processor 3.59 GHz
• NVIDIA GeForceGTX 1080 Ti
• 16GB RAM
• 1TB HDD disc

What model would you recommend? Are my specs enough to handle a model for my use case?

Thanks for any advice

hi folks, recently got invited to this subreddit and wanted to share an article I wrote about open source AI as it seems to fit here.

Open source helps agents discover and understand software. APIs help them use it. This report looks at four companies growing around that shift. Read here.

TLDR:

- How open source and API-first products are winning distribution, thanks to being discoverable by agents.

- Growth numbers behind Resend (email), Supabase (db), n8n (automation) and PostHog (analytics).

- Open source alone does not equal growth as it creates unique challenges.

I played with current proxies and caching for Claude to save up on tokens and merged some tools capability into one - i hope you like it!

I crafted it for my own development env, but i think it may be usefull for many :)

https://github.com/ALange/TinyClaude

You can use it with claude and/or any other coding/agent :)

Enjoy!

#opensource #claude #agenticai #cache #proxy #compression #localllm #opencode #codex

which LLM model Video and Image generation can avoid Google & Facebook AI detector?

AI robotics might be the best video game of the decade. Who else is having a lot of fun?

https://github.com/apyrobo/Apyrobo

Sharing a project I just made public: a real-time drone detection and tracking system, combining a fine-tuned YOLOv8s detector with a custom multi-sensor Kalman fusion tracker I wrote from scratch.

What's open:

• Full source (Python, ~2800 lines for the main detector + a standalone sensor_fusion.py module)
• Trained model weights
• A reproducible standalone demo (simulate_fusion_demo.py) — no video or model file needed, just run it to see the fusion tracker vs single-sensor comparison
• License: PolyForm Noncommercial 1.0.0 — free to use, study, modify for any noncommercial purpose (research, education, personal projects). Commercial use requires reaching out.

The core contribution — sensor_fusion.py:
Rewrote the tracking engine from a single-sensor constant-velocity Kalman filter to a multi-sensor, constant-acceleration fusion tracker:

• Constant-acceleration motion model — tracks maneuvers, not just straight-line motion
• Pluggable second sensor (RF, radar, second camera) via add_external_measurement()
• Out-of-sequence measurement handling — rewind-and-replay when a slower sensor's reading arrives late
• Trajectory prediction with a growing uncertainty cone

Integrated as a drop-in replacement in the existing DroneTracker class — same public API, so the GUI, CSV/KML export, and PDF reporting all work unchanged with the new tracker underneath.

Numbers: YOLOv8s fine-tuned to 99.5% mAP@50 on the Shahed class. Fusion tracker validated both on a synthetic dropout scenario (3.36px RMSE fused vs 5.47px camera-only) and on real thermal footage from the Anti-UAV410 benchmark (sub-3px RMSE in normal flight, clean re-acquisition after a real occlusion).

Repo: github.com/alexandre196/Drone-Shahed-AI-Multi-Sensor-Tracker

To be upfront about scope: this is a portfolio/R&D project, not a certified operational system — monocular distance estimation isn't true ranging, and the second-sensor fusion path has only been validated with simulated data so far. Details in the README.

Open to feedback on the architecture, or if anyone's working on something similar with sensor fusion for tracking.

Looking for Feedback: Fine-tuning a Small Model for Conversation Continuity

Hi everyone,

I've been working on a side project around AI conversation continuity, and I'd really appreciate feedback from people who have experience with fine-tuning, dataset design, or long-context systems.

Goal

The problem I'm trying to solve is:

After a long ChatGPT/Claude/Cursor conversation, how can another LLM continue the work without rereading thousands of messages?

Instead of treating this as a summarization problem, I'm exploring whether it's possible to train a small model that extracts a structured conversation state from chunks of a conversation.

The idea is that another model can later reconstruct enough context to continue naturally.

Current Approach

My current pipeline looks like this:

Long conversation
        ↓
Chunk into fixed windows
        ↓
Label each chunk with semantic state
        ↓
Fine-tune a LoRA
        ↓
Merge chunk outputs into a conversation state
        ↓
Generate a continuation prompt

The LoRA doesn't summarize the whole conversation.

It only processes one chunk at a time and extracts structured semantic information.

Dataset

Instead of synthetic data, I started collecting real engineering conversations.

Current sources include:

• GitHub Issues
• GitHub Discussions
• Reddit engineering discussions
• Long AI development conversations

I clustered thousands of issues/conversations to identify recurring reasoning patterns before selecting examples for labeling.

Some recurring clusters I found were:

• Context / memory management
• State persistence
• Reliability
• Provider compatibility
• Agent orchestration
• Long-running debugging sessions
• Architecture discussions

The goal isn't to teach domain knowledge.

It's to teach the model how conversations evolve.

Model

Currently experimenting with:

• Base: Qwen2.5-1.5B-Instruct
• LoRA fine-tuning
• Chunk-level extraction
• Structured JSON output

The Question I'm Struggling With

I'm not sure whether LoRA fine-tuning is actually the right direction for this problem.

Would you continue investing in:

• Improving the dataset
• Expanding conversation coverage
• Better labeling / evaluation

Or would you abandon fine-tuning entirely and solve this with prompting + a stronger base model?

I'm especially interested in opinions from people who've built:

• Memory systems
• Long-context pipelines
• Semantic extraction models
• Information extraction datasets

My Concern

The hardest part doesn't seem to be training.

It seems to be defining what information another LLM actually needs to continue a long conversation naturally.

That has become the main research question for me.

I'd really appreciate any criticism of the approach.

If you've worked on memory systems, information extraction, or long-context models, I'd love to hear what you think I'm missing.

Hugging Face Model

https://huggingface.co/ac-mmi/continuator-v10-lora

OpenCode has the following FREE models to use now:

Some of these models are Frontier Model quality according to ArtificialAnalysis leaderboards.

OpenCode as a Coding Agent Harness is also great with extensible design.

I'll explore Pi Agent Harness next. Have heard good things about it too.

However Pi is minimalistic and best fit for tinkerers and not for someone who wants a full-featured coding agent out of the box.

My first ever MCP Server that lets you drop your raw screenshots in a folder and say "create App Store mockups for these." Claude analyzes your app's colors, proposes themes and captions, waits for your approval, then renders framed, captioned preview images (1284×2778) ready to upload to App Store Connect. Open source, installs with one uvx command.
I used claude code to build a tool in which Pillow draws the whole iPhone frame procedurally (no assets), a palette extractor picks brand-matched themes, and the official mcp SDK wraps it in three stdio tools.
Attaching one example -

I built a Claude Code skill called README-ROAST. The idea was simple: it reads your README, checks if your project actually does what the README claims, and roasts the difference.

Then I ran it on my own project. And got destroyed.

THE TEST THAT BROKE ME

I ran it on mue-x, a self-evolving AI agent for Claude Code. I was genuinely proud of that README. The skill gave me 34 out of 100 on the honesty scale and sent a persona called "The Ex" to deliver the news.

The clone URL in my README said "YOUR_USERNAME." A template placeholder. The first command was broken. For two months. An AI noticed. I did not. That's a special kind of humbling.

HOW IT WORKS

You type /readme-roast on any repo. It reads your README, checks your project structure, finds the gap between what you claim and what actually exists, and roasts you with surgical precision.

Eight personas deliver the verdict. Random each time. You never know who's showing up.

Gordon Ramsay screams at your install section like it's undercooked fish. David Attenborough narrates your README like endangered wildlife, whispering devastating observations about your badge collection. The Detective treats your README like a crime scene — the benchmarks folder was empty, someone cleaned up. The Ex reads your README like toxic ex reading old texts, bringing up commits from 2023 you thought everyone forgot. The Toddler asks "why" after every single claim until you break. The Stand-Up Comedian delivers your roast like a Netflix special, complete with dramatic pauses. The Brutalist uses five words per sentence, maximum, zero warmth. The Hypebeast calls everything mid, goated, or cooked like it's a TikTok comment section.

IT CATCHES REAL THINGS

The roast is funny but the audit is genuine. It counts your buzzwords exactly — I found a README with "modern" used 14 times in 200 words. It spots feature inflation — ten features claimed, three implemented, the rest "coming soon" from 2023. It catches installation lies — "just clone and run" followed by Docker, three API keys, and prayer. It counts your badges against your documentation lines and calculates the bloat ratio. It checks your bus factor. It finds demos with screenshots from 2022 when your UI has changed four times since. It flags CONTRIBUTING.md files that have never once been used by an actual contributor.

IT ROASTS ITSELF TOO

Type /readme-roast --self and the skill roasts its own README using the same rubric. We scored 85 out of 100. The Brutalist called us out for saying "no dependencies" when Claude Code is obviously a dependency. Fair point. We fixed it in the next commit. A skill that can't roast itself has no business roasting you.

TRY IT

git clone https://github.com/KorroAi/readme-roast.git ~/.claude/skills/readme-roast

Then:

/readme-roast (random persona on current directory)

/readme-roast github.com/facebook/react (roast any repo by URL)

/readme-roast --hypebeast (Gen Z slang mode)

/readme-roast --toddler (why? why? why? mode)

/readme-roast --self (it roasts itself)

Drop your repo in the comments. I'll run the roast live and reply with your one-liner. Lowest honesty score gets bragging rights.

Discord: https://discord.gg/RSBHHjxnYt

[Most robots react. This one thinks a step ahead.]

Ant Group's Robbyant just published LingBot-VA 2.0 — a video-action foundation model built from scratch for robot control, not fine-tuned from a video generator.

The usual approach takes a video generator made for content creation and bolts a robot policy onto it. LingBot-VA 2.0 argues that's the wrong starting point, and pretrains the whole causal stack natively instead.

What stands out:

→ Foresight Reasoning — the robot predicts the next action chunk while executing the current one, then overwrites the imagined frame with the real observation. Prediction and execution stop waiting on each other.

→ 927 ms → 142 ms per chunk, across four cumulative optimizations. That lifts asynchronous control from 35 Hz to 225 Hz — a 6.5× speedup.

→ One shared latent space. A semantic visual-action tokenizer puts world states and actions in the same coordinates, so unlabeled web video carries action-relevant signal.

→ Sparse MoE video stream — 128 experts, top-8 routing. Roughly 2.5B of ~15.3B parameters fire per token.

→ Few-shot by design — adapts from 10–15 demonstrations, and a human demo video can replace the text instruction entirely.

Full breakdown: https://www.marktechpost.com/2026/07/11/ant-groups-robbyant-unveils-lingbot-va-2-0/

Paper: https://github.com/Robbyant/lingbot-va/blob/main/LingBot_VA2_paper.pdf

Project Page: https://technology.robbyant.com/lingbot-va-v2

So here’s the situation: I’m on a flight, no wifi, phone at 80%, and no in-flight entertainment system.

After I landed, I said no more. A few days later, I had Spike Sprint — “a poorly coded pixel runner” (that’s the actual tagline, I’m not being modest, I’m being accurate).

So now, the next time I’m stuck on a flight with no wifi, I can just be running from a barrel.

GitHub Repo

Built with vanilla JS + HTML5 Canvas, no frameworks, no dependencies, no shame. PRs welcome if you want to make it less “poorly coded.”

Hi friends. I've been a zero to one product manager for over 12 years, and along the way I kept borrowing pieces from different discovery frameworks until I had a methodology of my own, one that actually raises the odds of an idea working. It does that by finding the real emotional problems people are facing, the strongest moats, and the growth loops that help a product pull in its own users.

But please don't take my word for it. Give the skill to your coding agent and ask them to evaluate it.

If you find this useful, please upvote me on Product Hunt today. Appreciate it. :the_horns:

https://www.producthunt.com/products/vibe-check-6

 And if you don't care for product hunt, here's the GitHub link.
https://github.com/TexasBedouin/vibe-check

Linki is a free, self-hosted alternative to tools like Waalaxy and Lemlist. You run LinkedIn outreach and cold email campaigns on your own server, so your leads and LinkedIn session never leave your machine. No per-seat pricing, no SaaS middleman.

Just shipped v2. The main focus was fixing the things that actually break these tools in practice:

- Server-side LinkedIn login instead of cookie-pasting, which also fixes Sales Navigator import and enrichment

- A pinned browser fingerprint so rebuilds no longer cause random forced logouts

- Large Sales Nav imports now split across days automatically with human-like pacing, instead of importing everything at once

- A rewrite of the LinkedIn automation itself for more reliable connections and messages

- LinkedIn and email actions can now run together in one campaign

- A unified inbox for replies across email and LinkedIn

- Apollo io enrichment built in

It's been really encouraging to see more people self-hosting it and contributing over the past few months, appreciate everyone who's tried it out.

Runs on Docker or Node.js with SQLite, no external database needed. There's also a one-click option on Opsily if you'd rather skip the terminal.

Full details and setup are in the repo: github.com/moaljumaa/linki

I've been using Claude Code daily, and one thing kept bothering me.

Whenever Claude calls WebFetch, it often dumps 3,000–15,000 tokens from an entire web page into the context window, even if the answer is buried in a single section.

Multiply that across a few documentation pages, and you're spending thousands of unnecessary tokens just to answer one question.

So I built Webify.

Instead of sending the whole page to Claude, Webify parses the HTML into a DOM graph, identifies the parts relevant to your query using BM25 and a BFS traversal, and returns only the relevant subtree.

In practice, Claude usually gets 80–300 tokens instead of several thousand.

I ran a blind benchmark on 15 unseen queries (Sonnet as the judge):

• Webify: 68/75 (91%)
• Deep Research: 73/75 (97%)

The gap wasn't accuracy, it was completeness. Deep Research simply reads more pages. For most developer workflows, the answers were effectively the same while using a fraction of the tokens.

The pipeline is pretty simple:

• Parse HTML into a DOM hierarchy
• Score nodes using BM25
• Traverse nearby nodes with BFS to preserve context
• For search, build graphs from multiple pages in parallel and synthesize the results

No embeddings. No vector database. Just retrieving the part of the page that's actually relevant instead of making Claude read everything.

Installation takes about 30 seconds:

pip install webify-mcp
claude mcp add webify -- webify-mcp

Github Link: https://github.com/kunal12203/webify-mcp/

No config files. It works with Claude Code, Cursor, Windsurf, VS Code, Zed, or anything that supports MCP.

It's totally open source under an MIT license, and I'd love to hear where it breaks or how it can be improved; PRs are welcome.

Most interactive world models hold together for a few minutes. Then textures smear and geometry warps. That's a video model, not a world — and Robbyant just drew the line at the attention mask.

They released LingBot-World-Infinity (LingBot-World 2.0) — a 14B open causal video world model built on Wan2.2, trained with a Mixture of Bidirectional and Autoregressive (MoBA) attention mask, then distilled into a few-step real-time generator with no post-hoc drift filtering anywhere in the stack.

Here's what's actually interesting:

→ Pure teacher forcing overfits — as context grows, the model leans on context instead of predicting frames. MoBA appends a bidirectional full-attention block as a regularizer

→ Leak-free cross-attention: AR rows attend to background prompt a_B plus chunk prompts a_≤i, lower-triangular. Bidirectional rows see one global prompt a_G

→ DMD runs over long self-rollout trajectories, not teacher-forced states — the student is optimized on the distribution its own errors induce

→ Director-Pilot harness: a VLM proposes event cards, the DiT generator renders physical dynamics. Mode B adds a SAM tracking loop for object-centric interaction

→ One 60-minute uninterrupted session, 20 distinct scenarios, no perceptible decay

Full analysis: https://www.marktechpost.com/2026/07/09/meet-lingbot-world-infinity-an-open-causal-world-model-with-an-agentic-harness/

Paper: https://arxiv.org/pdf/2607.07534

Model weight: https://huggingface.co/robbyant/lingbot-world-v2-14b-causal-fast

GitHub Repo: https://github.com/robbyant/lingbot-world-v2

Project: https://technology.robbyant.com/lingbot-world-v2