and embeddings support multimodality --> *BY DEFINITION*
images, text, documents, audio...it really does not matter
embeddings ftw
end of the rant
time to build
SOMEONE VIBE CODED A CHROME EXTENSION THAT DISGUISES CLAUDE AS A GOOGLE DOC SO YOU CAN USE AI IN PUBLIC
it wraps ai in a fake google docs interface, so on your screen it just looks like youre typing a document, not prompting a chatbot
what it does:
> works with chatgpt and claude
> you just type your question like a normal line in a doc and the answer comes back right there on the page
> microsoft word and notion style themes too, so you can pick your disguise
> rebuilt to properly support multiple ai models behind the doc
> the google docs look is the default
its a chrome extension called gptdisguise
this is genius.
a lot of people are embarrassed to be seen using ai in public (school, work, etc). someone just built the fix.
You're telling me that for the past 50 years there's been a one-line closed form expression for Black-Scholes inverse volatility that nobody bothered to discover until some rando shadow dropped this on ArXiV? https://t.co/2rjhCEVxQG
We’re excited to introduce Doc-to-LoRA and Text-to-LoRA, two related research exploring how to make LLM customization faster and more accessible.
https://t.co/ApVzVsBuv1
By training a Hypernetwork to generate LoRA adapters on the fly, these methods allow models to instantly internalize new information or adapt to new tasks.
Biological systems naturally rely on two key cognitive abilities: durable long-term memory to store facts, and rapid adaptation to handle new tasks given limited sensory cues. While modern LLMs are highly capable, they still lack this flexibility. Traditionally, adding long-term memory or adapting an LLM to a specific downstream task requires an expensive and time-consuming model update, such as fine-tuning or context distillation, or relies on memory-intensive long prompts.
To bypass these limitations, our work focuses on the concept of cost amortization. We pay the meta-training cost once to train a hypernetwork capable of producing tasks or document specific LoRAs on demand. This turns what used to be a heavy engineering pipeline into a single, inexpensive forward pass. Instead of performing per-task optimization, the hypernetwork meta-learns update rules to instantly modify an LLM given a new task description or a long document.
In our experiments, Text-to-LoRA successfully specializes models to unseen tasks using just a natural language description. Building on this, Doc-to-LoRA is able to internalize factual documents. On a needle-in-a-haystack task, Doc-to-LoRA achieves near-perfect accuracy on instances five times longer than the base model's context window. It can even generalize to transfer visual information from a vision-language model into a text-only LLM, allowing it to classify images purely through internalized weights.
Importantly, both methods run with sub-second latency, enabling rapid experimentation while avoiding the overhead of traditional model updates. This approach is a step towards lowering the technical barriers of model customization, allowing end-users to specialize foundation models via simple text inputs. We have released our code and papers for the community to explore.
Doc-to-LoRA
Paper: https://t.co/87xEEpf0GN
Code: https://t.co/zBfQi2L9LW
Text-to-LoRA
Paper: https://t.co/emLRZ4Vdvo
Code: https://t.co/b9mrdoWWRB
1/ The DOM was a mistake.
Not a necessary evil. Not a tradeoff. A mistake. We've spent 30 years building an elaborate abstraction tower on top of a pixel grid — and the entire thing optimizes for the wrong consumer.
🧵
---
2/ The box model was a document layout hack from 1996. It was designed so humans could write <div> tags by hand.
That constraint shaped everything: CSS, reflow, specificity wars, layout thrashing, the entire frontend industrial complex.
But what if the human was never supposed to be the author?
---
3/ Here's the idea:
What if instead of an empty tree you fill with boxes, the screen started FULL — pre-tessellated with self-fitting geometries that get morphed into UI elements at runtime?
No DOM. No reflow. The display surface is the primitive.
---
4/ Think Voronoi cells, Penrose tilings, recursive subdivisions — geometries that already fill the screen with zero gaps.
Layout cost? Zero. The space is already partitioned.
Responsiveness? Topological, not pixel-based.
GPU-native? From birth.
---
5/ "But how do you make a button?"
You don't make anything. You SELECT cells and PROMOTE them.
A morph rule coalesces adjacent cells into a region, binds it to a semantic role, and interpolates the shape toward readability. Rectangles are an output, not an input.
---
6/ Now the real punch:
Make the morph rules a convex optimization problem.
A design objective function with adjacency, readability, and hierarchy constraints. Convex = globally optimal, real-time solvable, and — here's the kicker — differentiable.
---
7/ A differentiable UI layout means the interface literally optimizes itself.
No more A/B testing 47 button colors. Define the objective. The solver finds the layout. The tessellation morphs. Continuously. With mathematical convergence guarantees.
---
8/ The stack:
Intent (AI or human)
→ Convex design function
→ Real-time solver
→ Tessellation morph
→ Pixels
5 layers. Each mathematically grounded. No CSS. No DOM. No reflow. No specificity. No "why is this 1px off."
---
9/ "This will never work, devs need to read layout code."
Do they? Or did they USED TO?
If an LLM is generating your UI, it doesn't care about divs vs tessellation cells. It cares about intent → pixels. This model is easier for AI to target than the DOM ever was.
---
10/ The DOM was a human-writable abstraction.
AI agents don't need human-writable.
We've been optimizing the wrong interface for the wrong consumer. Time to De-SaaS the DOM.
Building this. Come fight me.
we need an embeddings filesystem, embeddings-based applications, embeddings-based databases (more than just for similarity search) and modern /reliable embeddings monitoring systems
embeddings are the real deal, but honestly nobody asked for *vector databases*.
We need vector data models, something like *embeddantic* (pydantic + embeddings).
so that we can use embeddings directly throughout our applications, enabling semantic computation.
vector databases are just one piece of the vector embeddings infra, and Im afraid they are suffering from premature convergence to *local* trends like RAG + pre-trained vector embeddings.
faiss, annoy and milvus were the first talking about efficient, approximate, vector similarity search, mostly for recsys applications used on top of *learned* embeddings.
A pile of pre-trained text embeddings in a vector db is, imo, a very very shallow usage of what we have learned from representation learning all these years, and rag is just atrocious from a IR perspective.
The buzzwords seem to have won over common sense that you just cant expect to compress 8k tokens into a 1500ish dim vector, from a pre-trained model, and have very good results.
The blog posts convinced everybody that the golden standard is: 1) converting text into a single dense vector 2) performing approximate nearest neighbor (with what params btw?!?) 3) stuffing everything into a long autoregressive network. aren’t these errors all compounding?
I am all in on embeddings as first class data citizens.
stay dense, everybody. stay dense.
📣 Open call to agent builders: Let's read agent skills from `.agents/skills`, so people don't have to manage separate folders per agent.
Today we pulled the trigger for Codex to read `.agents/skills`. Goal is to deprecate `.codex/skills`.
Pls like/tag/RT for momentum.
we did it! Mycelia is now SOTA on ontology alignment benchmarks (Ontology Alignment Evaluation Initiative 2025) - without using hardcoded domain rules and most importantly, without LLMs.
with full formalisms and consistency guarantees. the whole system runs AIR-GAPPED - no LLMs, no external internet access needed. already in production for medical audit workflows, insurance classification and prediction and also for BPO workflows - at 0 costs with tokens