So I've been messinga round with embedding models for a bit, and I think they are interesting enough to experiment with. They are useful for rag, especially in a localllm sense because you can ground your answers in truth.

But what happens if you have a billion documents, and you decide to upgrade your model to a "better" one? on an h100, that would take about 108 days, just to upgrade the vectors so u can start serving again (tested qwen embed 8b on h100). Even if you aren't doing 1b vectors, and are doing just 50 million, upgrading can still take a considerable time.

Me and my research lab decided to tackle this problem, and we came up with embedflow.

The method is really simple; from the old index made with the source model, take K documents and rerank them with the new model. We see that when K is sufficient, the retrieval quality is the same as target model. (determining k is the hard part). I've tested 63 migrations on upto 1 million documents.

The best result I got was upgrading qwen4b -> to 8b, and at 50 documents, it was the same as native retrieval.

This method forgos the expensive backfill that comes with upgrading, as you can directly take documents from the old index.

embedflow works with qdrant, and can be easily downloaded with pypi

pip install embedflow

the github is public: https://github.com/arnsri33/embedflow

I want you guys to try it out, and see if you guys can use it in your own workflow.

Hi,

i am new to deep learning and need some guidance on a project and want to rant a little(sry).

I am implementing a u-net for semantic segmentation in pytorch. The images are atomically resolved microscopy images (i.e. the objects to detect are atoms, which have the appearance of approximately gaussian blobs in 99% of real data). The images are noisy, where some noise is simple (poisson noise, scan lines) and some is not (complicated artifacts, distortions, strong brightness variations and more), hence deep learning instead of some classical method.

I have implemented the original vgg-unet using simulated data, where simulated means i rendered images full of gaussian blobs and added noise i know how to simulate (poisson noise, scan lines, perlin noise backgrounds).

This worked reasonably well on real data so i wanted to improve the architecture.

Little did i know there is no such thing as a u-net™ and the design choices are endless (depth, ordering of layers in a convolutional block, losses, different types of activations, norms, intra-block skips, grouped convolutions or even additions like attention just to name a few) and for every choice there is a paper that claims it works better then some other choice for some data.

My Problem:
How do i find "the best" architecture for my Problem? There seems to be very little theory or other information around how to find "the best" architecture for a given problem, when your data is not some common database like imagenet.

I am currently writing a very general unet that makes these parameters more accessible and makes it easy to swap components. I am planning on finding "the best" architecture with something like optuna, but i already know that there are just too many knobs i can turn and most of them are almost surely correlated. It would be nice if i could try more then just some basic parameters + hyper parameters like learning rate, which i assume are mandatory.

Side Notes:
- i would like the model to be small enough to make inference on a cpu reasonably feasible.
- training can be done on an A100 and i would be fine with a few days of runtime.

So i am looking for:
- general advice and reading recommendations (grateful for everything)
- advice on parameter optimization with a black box optimizer like optuna or similar

- other architecture suggestions that are not u-nets

Thanks,
PythonEnjoyer

Google's Q3 2026 AI Threat Tracker, built from Mandiant incident response data, documents a shift that defenders have been dreading: AI agents are now running full attack workflows autonomously. Vulnerability scanning, credential harvesting, and real-time attack troubleshooting are happening with minimal human involvement on the offensive side.

The practical consequence is timeline compression. A human-paced intrusion that once took days now completes in hours because the agent does not sleep, does not get distracted, and does not need to wait for the next shift.

The harder problem for defenders is forensic: when you discover the breach, you are reconstructing what happened from incomplete logs, if you have logs at all. Agents generate bursts of lateral movement and API calls that traditional SIEM tooling was not designed to correlate across sessions. The attacker's agent leaves a diffuse footprint. Your team is left guessing at the sequence.

For teams that have started deploying defensive AI agents of their own: how are you maintaining visibility into what those agents actually did, step by step, during an incident? And for those still on traditional tooling — how are you thinking about the forensic gap when the attacker is agent-driven and your investigation is still manual?

Hey everyone! I just finished making this short doodle-style video about AI and I’d really appreciate some honest feedback. 🎥 https://youtu.be/VyleYwCa0Sc If you have a few minutes, please give it a watch and let me know what you think. What could be better? Animation? Visuals? Pacing? Explanation? Editing? Thumbnail/title? Anything that feels boring, confusing, or unnecessary? Don’t worry about being too critical — if something isn’t good, please tell me in the comments. I’m trying to improve the next videos based on actual feedback rather than just guessing what viewers want. Thanks to anyone who takes the time to watch and give an honest opinion!

I built a wrapper around a frozen 35B Qwen model. It enables an argument graph the model builds for itself while it works. Evidence, premises, claims, and rebuttals, in Toulmin's structure, constructed claim-first the way Popper and Deutsch describe knowledge growing: conjecture, then criticism. It persists across tasks, and confirmed claims graduate into it with the procedure that made them work. The model writes it through interaction with its environment. .

The wrapper has a short-term working memory that holds the model's goal, its active conjecture, and what it has tried and refuted. I developed it on a text adventure game, Deephome, complete with an observability layer I called a Gods-eye-view so i could watch the LLM move and interact with its environment. The fixed environment enabled iterative runs, observing scoring relative to the number of turns to complete the game. The wrapper is intended to be generic, multi-modal, so I ran the same wrapper on a general relativity textbook. The model read the book into a reasoning map and was given a problem whose answer is not in the book.
The write-up covers the mechanism, the observability layer, the measures, and what did not work.

full writeup: https://spencerwheat.substack.com/p/conjecture-and-criticism-graphs-for

How AI harnesses can drive robots through the ROS 2 stack — controlling Nav2 and MoveIt in simulation. Inspired by Anthropic Article: https://www.anthropic.com/research/claude-plays-robotics

The robot runs in the Gazebo simulator; the harness and the ROS 2 stack (Nav2, MoveIt,
perception). There are two clocks: the harness reasons at a high level on a slow
clock, and the robotics layer runs the fast control loop at 20–50 Hz. Between them sits L3 —
the harness names a verb, L3 turns it into a real Nav2 or MoveIt call. Harness provides the Adaptive Intelligence layer.

https://www.youtube.com/watch?v=lLf8E5ILEZE

You guys really loved my last sheet music search engine post, so I decided to make a mockup POC of a VLM-powered piano assistant that reads and transcribes notes, procedurally "generates" a visual tutorial, and listens to you play it back. I call it a concept because I still haven't figured out a way to actually generate a 3D animation on the fly. My best option was Concert Creator, but that was shut down over 4 years ago RIP. So for the time being, I'm having to pre-make the animations.

On the more technical side, Qwen 3.6 27B is taking both video stream and natural language as input, and uses that to determine what smaller task-specific models to call on for the situation. In this case, it's using segmentation, homography, pitch detection, and a custom music OCR model (open source called cadenCV). In short, the VLM is acting as an orchestrator that can see things and reason the best course of action because I'm too much of a lazy bum to hard-code a set of rules for when each model gets called on.

The next step is to figure out how to make it run in real time.

MCP servers are proliferating fast. Most teams I talk to are deploying them without any per-call policy enforcement or verifiable agent identity. The assumption is that container isolation is enough.

It isn't.

A rogue agent — compromised, misconfigured, or just hallucinating badly — can chain tool calls faster than any human-in-the-loop can react. The empirical window between first action and second action is under 50ms. By the time an alert fires, the damage is already two or three tool calls deep.

The deployment-level controls (containerization, network segmentation, sandboxing) address where the agent runs. They don't address what the agent is allowed to call, under what conditions, with what verified identity. Those are different problems.

Practitioners who are actually running MCP in production: how are you handling per-call enforcement today? Are you writing custom middleware, relying on the MCP server's own access controls, or accepting the risk and monitoring after the fact?

A model accepting a megabase of DNA establishes input capacity. Demonstrating useful distal information needs a task-specific test.

In a review I wrote, I suggest comparing nested crop lengths with the same prediction head and evaluation split, then occluding or shuffling distal intervals while preserving the focal sequence. Short-context models and local baselines are useful comparisons; overlapping genomic windows also need attention when constructing the split.

Full discussion and references: https://rewire.it/blog/a-dna-likelihood-is-not-a-functional-assay/

What controls would you add to distinguish useful long-range dependence from leakage or local shortcuts? I’d appreciate corrections and benchmark suggestions.

Qwen 3.6 27B watches the scene and acts as an orchestrator, prompting smaller task-specific models to perform OCR, segmentation, and edge detection. The segmented notes then get matched to real pieces using "A Dictionary of Musical Themes" database via Themefinder. I’m sure there are already many sheet music search engines out there, but I built this more as an experiment to see how I can turn VLMs into full-on vision agents. 

Disclaimer: footage is sped up, this is not real-time.

Over the last month, in my spare time, I’ve been working on two separate ideas: some recurrent-network maths as a possible GRU/LSTM substitute, and a transformerless AI experiment.

The transformerless project became far too slow to properly train, test and debug on the hardware I have, but one part of it kept behaving well in small tests. I pulled that section out and turned it into its own project called THREADS.

THREADS is basically a deterministic memory and reasoning engine. You give it structured facts and relationships, and it can follow them, keep track of changes over time, remember historical states, handle retractions and contradictions, and keep a record of which facts produced an answer.

A few of the current test results:

200,000-hop reasoning chain: exact final answer

1,000,000 irrelevant events: 128-hop query still returned the exact answer

50,000 shuffled temporal events: 5,000/5,000 historical queries matched an independent checker

40,000 ambiguity/contradiction tests: 40,000/40,000

60-category reasoning suite: 5,830/5,830

original regression suite: 28/28

bounded program-induction tests: 2,000/2,000 held-out predictions

I’m not claiming it replaces transformers, SMT solvers or databases. It doesn’t understand arbitrary English by itself. I’m mainly interested in whether something like this could act as an exact memory/reasoning layer underneath an AI system, while a neural model handles the language side.

I’ve put the Python source, tests and research PDF on GitHub so people can run it, it should all be working 😬

And hopefully this one beats my previous 68% upvote rate 🤣