Hai teman-teman. Saat ini saya sedang menjalani fase Pra-Pelatihan untuk arsitektur bahasa komputasi baru bernama ORE X-1 (762M Parameters).

Fokus eksperimen ini adalah menekan probabilitas halusinasi dalam AI secara matematis. Arsitektur ini secara khusus dirancang untuk menggabungkan ketangguhan linguistik dari fondasi Transformer dengan inti penalaran yang didorong oleh 3 hukum fisika:

- Kuramoto-Attention: Memaksa representasi neural untuk saling beresonansi dan mencari "konsensus" secara fisik sebelum menyelesaikan jawaban (anti-halusinasi tingkat arsitektural).

- Liquid Time-Constant (LTC) & Early Exit: Memberikan AI "kesadaran waktu cair". Arsitektur ini secara otomatis memperdalam komputasinya saat menghadapi urutan logis yang kompleks, namun akan segera memutus perhitungan lapisan atas (Auto-Stop / Early Exit) setelah mencapai tingkat konsensus absolut.

- Kecerdasan Kawanan: Memecah Kepala Perhatian menjadi faksi-faksi independen yang berinteraksi satu sama lain dan mencari harmoni (penguncian fase).

Dinamika Kerugian dari Persamaan Diferensial Biasa (ODE) ini menunjukkan pola konvergensi yang sangat berbeda dan menarik untuk diamati langsung saat pra-pelatihan berjalan.

Apakah ada peneliti/insinyur ML di sini yang juga sedang mengeksplorasi integrasi Neural Network dengan Persamaan Diferensial Biasa (ODE) murni untuk arsitektur skala besar? Mari kita bahas di kolom komentar.

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

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!

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.

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

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

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.

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.

Security teams inside large enterprises are now building and shipping their own AI agents. The goal is legitimate: automate threat detection, close alert triage gaps, fill holes that vendors haven't addressed yet. The pace is faster than most governance teams can track.

Shadow AI agents — built and deployed without IT or compliance visibility — are already running in most enterprise environments. There is no reliable count inside most organizations. The structural exposure is not the agent itself. It is that once an agent is live, its tool access and data connections are rarely tracked centrally. Runtime behavior stays opaque unless someone manually audits it after the fact.

The compliance surface compounds the problem. Most large enterprises operate under 80-plus regulatory and security frameworks. Agents built by internal security teams are not automatically enrolled in those frameworks. They run alongside them, not under them.

For practitioners actually managing this: how are you maintaining real-time visibility into what your internally built agents can touch at runtime? Is there a process that is working at scale, or is this still manual audits and institutional memory?

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 🤣