Kallirroi Dogani

At the end of last year, we started working with GenomeKey on two key hires - a Senior Data Engineer and an ML Engineer. Both roles came with some very specific technical asks. The ML search in particular went down an interesting route, with sourcing centred around mapping relevant publications and reaching out directly to researchers. The eventual hire was identified through her work published in Nature Portfolio. Both hires are now in place, and we've received some brilliant feedback from the founding team and the hires themselves. If you're an AI Founder in growth mode, reach out to my AI team at Cubiq Recruitment. Our specialist in BioAI is Joe Phillips. #Casestudy #AIscaleup #BioAI #DataEngineering

8

Anthropic’s new model, Sonnet 4.5, just dropped, specialised in coding and agentic processes. Let’s see who introduces a new benchmark-crushing competitor in the coming weeks… Some thoughts from someone who had early access and time to test it: https://lnkd.in/enea6yfW

16

1 Comment

𝗘𝘃𝗲𝗿 𝗳𝗲𝗲𝗹 𝗹𝗶𝗸𝗲 𝘆𝗼𝘂𝗿 𝗥𝗔𝗚 𝘀𝘆𝘀𝘁𝗲𝗺 𝗶𝘀 𝗴𝗶𝘃𝗶𝗻𝗴 𝘁𝗲𝗰𝗵𝗻𝗶𝗰𝗮𝗹𝗹𝘆 𝗰𝗼𝗿𝗿𝗲𝗰𝘁 𝗯𝘂𝘁 𝘂𝗻𝗵𝗲𝗹𝗽𝗳𝘂𝗹 𝗮𝗻𝘀𝘄𝗲𝗿𝘀? Often it’s not the LLM’s fault - it’s the Retriever. In a typical RAG pipeline, the retriever is like a fast librarian grabbing the top 10 chunks based on similarity. But 'looks relevant' doesn’t always mean 'really answers the query'. This is where 𝗥𝗲𝗿𝗮𝗻𝗸𝗲𝗿𝘀 come in. They are the Quality Control for your AI. --- How Rerankers Work 1. The Retriever (Stage 1): You scan 1,000 resumes for keywords like 'Python' or 'AI'. You quickly narrow it down to the top 20 candidates. This is fast and cheap but might miss a hidden gem. 2. The Reranker (Stage 2): You sit down and actually read those 20 resumes side-by-side. You look for nuance, experience, and reorder them so the #1 candidate is truly the best. Slower but more accurate. --- A Simple Example Query: 'What is the refund policy for broken items bought on sale?' Retriever finds:  • A doc about general sale items (High similarity).  • A doc about broken items (Medium similarity).  • The actual specific policy for broken sale items (Lower similarity because of word matching). Reranker fixes it: It looks at the query and the docs together (Cross-Encoding). It realizes Doc #3 is the one that actually answers the question -> moves Doc #3 to the top spot before the LLM even sees it. --- Why Rerankers Are Essential? 1. Reduce Hallucinations: If the LLM gets poor context, it will invent answers from noise. Rerankers ensure the context fed to the model is signal-rich. 2. Context Window Efficiency - Better chunks = fewer passed into the LLM, saving tokens and cost. --- The Bottom Line: If you want a production-grade RAG, you should consider - Retrieve then Rerank. ♻️ Share it with your network if you find it useful, and follow Mayank Sultania for more practical AI tips. Use top rerankers: https://lnkd.in/gRRRetDu Are you using a reranker in your pipeline yet, or are you still relying on raw vector search? Let's discuss in the comments! Image by: Simone Fuscone #RAG #AI #MachineLearning #LLM #SearchEngine #GenerativeAI #NLP #DataEngineering

19

My latest Medium article explores practical techniques for using LLMs to generate structured outputs from text and images. Small, local-running models are becoming increasingly capable at this very useful task! https://lnkd.in/ep3U4Rrx

23

I have published a blog on medium.com to introduce a decentralized LLM inference network called Momahub, which is enabled by SPL - Structured Prompt Language. https://lnkd.in/eX-KQU5W

14

Can't make it to #ACL2025 this year, but for people interested in RL for factuality and textual decomposition, please check out our paper: https://lnkd.in/ed3zPXfY TL;DR: We found a mismatch between the decomposition policy and LLM verifier, and propose a dynamic training paradigm to bridge the gap. This is our teaser video 😀 https://lnkd.in/epQukV8p

39

Testing across Claude, GPT, and Gemini with paradoxical prompts showed rapid oscillation between coherent and incoherent states rather than gradual degradation as often seen with humans. Models with higher meta-cognitive awareness (recognizing contradictions) maintained better overall coherence despite the paradoxes. GPT showed highest susceptibility with lowest meta-awareness, while Claude demonstrated highest meta-awareness with moderate susceptibility. Code and data: https://lnkd.in/ekG3YPMm

7

2 Comments

Academic Friday, so new paper alert (https://lnkd.in/eUZHts2k) ;). LLMs have reignited the previously relatively niche area of multi-agent systems, by making it easier to sense, plan and (inter)act. But agents are also turning passive LLMs/FMs more into autonomous, active, situated and grounded systems. Want to get an overview of the field? Then check out our recent survey paper "Agentic Large Language Models, a survey", by Aske Plaat, Max van Duijn, Niki van Stein, Mike Preuss, Peter van der Putten, Kees Joost Batenburg. #agents #agentic #LLM #AI #GenerativeAI LIACS

51

AI for Children? A Growing Reality A recent study by The Alan Turing Institute found that nearly 1 in 4 children aged 8–12 in the UK have used generative AI tools, but these tools are not designed with children's interests in mind. We often build AI or low/no-code tools assuming a specific audience, but in reality, they're being adopted by other user groups, including kids. While this opens exciting opportunities for creativity and learning, it also raises critical questions around safety, usability, and responsible design. As AI tool builders, we must consider: - Who might use our tools, even if they're not the target audience? - Are we designing for safety, inclusivity, and responsible use? -How can we adapt our designs to serve diverse and unintended users better? Designing AI responsibly means thinking beyond the "ideal" user and anticipating real-world usage. Link to the report in the comments.

3

1 Comment

Went through the Agentic AI MOOC from Berkeley RDI Something the course touched upon was Agent Evaluation. A lot of current evaluation being used for agents is essentially LLM evaluation; in this schema, the benchmarks only look at the final text output quality. This doesn’t fully capture the behavior of agents which have more complex behaviors such as tool usage, state and memory, and planning. Agents also live in a dynamic environment where the state may change, whereas LLM’s live in a static environment. To address these behaviors a shift from static benchmarks to dynamic benchmarks can better measure agent ability. Rather than having a dataset of inputs with deterministic, correct answers, dynamic benchmarks involve creating entire environments for agents to operate in. Within this environment, we can measure the decisions the agent makes at each step, tool usage, user interactions, and the resulting effects on the environment. We can then see how these decision led to the final result. The correctness of the agent’s decisions can be measured using human verifiers or “LLM-as-a-Judge” verifiers. With better evaluation benchmarks, researchers can make better-informed decisions on improving Agents. Link to MOOC: https://lnkd.in/eTfTnj6N

5

2 Comments

🚀 Benchmarking Local LLMs Like a Pro I just published a step-by-step guide on building a resumable evaluation pipeline for local Large Language Models (like Gemma 3 via Ollama). No more rerunning 10,000 examples if your script crashes—think save-game checkpoints for AI experiments. 🔗 Read the full blog here: If you’re working on LLM benchmarking, retrieval-augmented generation, or local inference workflows, I’d love to hear your thoughts! #LLM #MachineLearning #Python #Ollama #MLOps

8

2 Comments

RLM + REPL for agents Amid all the noise (new models, post-training, etc.), the RLM idea stood out. Inference strategies aren’t “sexy,” but they matter daily (CoT, ReAct). If you care about context rot and performant agents, this is interesting. Original blog post from the authors: https://lnkd.in/gzFXx9Ex 𝗪𝗵𝗮𝘁 𝗰𝗹𝗶𝗰𝗸𝗲𝗱 REPL as the primary action space for the agent. Offload context into code → fight context rot and tame big contexts by turning understanding into variables/functions. Models can spin up tools on the fly when needed. 𝗪𝗵𝗲𝗿𝗲 𝗱𝗶𝗱𝗻'𝘁 𝗰𝗹𝗶𝗰𝗸 More code = more chances to error. Failed execs make REPL state management messy (partially defined vars, out-of-order lines). In production, you usually want stable, hand-crafted tools; relying on the model to recreate them each run adds randomness and latency. 𝗩𝗲𝗿𝗱𝗶𝗰𝘁 Super promising pattern, and I’ll keep following it. For now, not a drop-in replacement for good old loops + templated prompts + curated tools—but a strong lens for designing agent inference. Repo with my small tweaks (LiteLLM + some async): https://lnkd.in/g63tdJt3

10

1 Comment

🚨 Small number of poisoned samples can seriously compromise LLMs! I just read an eye-opening study by Anthropic, UK AISI, and The Alan Turing Institute titled “A Small Number of Samples Can Poison LLMs of Any Size.” Their core finding is astonishing: with as few as ~250 malicious documents, an attacker can successfully insert a “backdoor” into large language models (ranging from 600M to 13B parameters) — causing them to misbehave on specific trigger phrases — regardless of the total training data size or model scale. This marks a major shift from the earlier belief that an attacker must control a proportion of the dataset. Instead, this research shows that it’s the absolute number of poisoned samples that truly matters. The full technical paper — “Poisoning Attacks on LLMs Require a Near-constant Number of Poison Samples” — dives deeper into the experiments and implications. 📄 Read here: https://lnkd.in/gje8V-76 🎥 Watch a great explanation: https://lnkd.in/gMk68vj3 🙏 Thanks to Krish Naik for breaking it down so clearly!

34

2 Comments

Third and final part of my series on SLMs, talking about where they run and where things are heading. I think there is immense practical value in SLMs and with growing agentic systems we might see more and more SLMs handling tasks in production environments.

12

🤯 Are LLMs a dead end? That's the provocative claim from Richard Sutton, the Turing Award winner widely considered the "father of Reinforcement Learning," in a new interview with Dwarkesh Patel. His core argument is a huge challenge to the current AI zeitgeist: Sutton argues that Large Language Models are fundamentally about mimicking people, not understanding the world. They excel at predicting the next word a human would say, but they lack true goals and the ability to learn from experience; the way every animal, and every human, actually learns. He believes this is another chapter of his famous essay, "The Bitter Lesson." We're seduced by putting human knowledge (trillions of tokens) into our systems, but the truly scalable, long-term path to AGI will come from agents that learn directly from interaction and feedback, not from a static dataset. ### My Take as an Engineer Honestly, I think Sutton is spot on. Scaling up LLMs will eventually hit a wall and is definitely not the path to true AGI. As the father of RL, he knows that real intelligence comes from continuous interaction with the world and learning from the outcomes of those actions. We're already seeing the industry move in this direction. Researchers are building complex virtual environments for models to learn in, and data from robots interacting with the physical world will be the next frontier. I think many people in AI realize that scaling LLMs isn't the solution to everything. That said, LLMs are phenomenal at what they were designed for: interpreting and producing natural language. They serve as an amazing interface between humans and the worlds of code and data. They're a critical piece of the puzzle, just not the whole puzzle. What do you think? Is Sutton a contrarian, or is he seeing the writing on the wall that the rest of us are missing? 👇 Let's discuss. See https://lnkd.in/dz9deseE for the full interview! #AI #ReinforcementLearning #LLM #ArtificialIntelligence #MachineLearning #TheBitterLesson #FutureofAI

4

New blog post, Using Claude Code to help me write https://lnkd.in/ekx7mZmn Everyone should already be using the LLMs as a copy-editor (and that should be relatively uncontroversial). But this post also shows a simple set up, having Claude Code review your prior writing before generating new content. After that just have a detailed outline, and the results on the first pass will be similar to your own voice. You still need to manually review for accuracy, but the outline approach and filling in small sections at a time, should mitigate errors and make it easier to review.

15

4 Comments

In my previous post I wrote about fine-tuning an in-house LLM for travel recommendations. This post is about why owning the model stack turns latency into an advantage. (previous post - https://lnkd.in/dZS6934P) One of our recent papers, “Speed Without Sacrifice” (link in comments 👇), won the Industry Track Best Paper Award at ACL 2025. For me, the most interesting part is not the award (though kudos to our amazing team including Moran Beladev, Manos Stergiadis, Ilya Gusev and Eran Fainman), but what it says about building GenAI systems at scale. When you rely on third-party models, latency is a fixed parameter. You pick a model. You pick a tier. You live with the response time. With open-source models, latency becomes something you can actively design for. Together with our long-time partners at AWS, Daniel Zagyva, Laurens van der Maas, and Aleksandra Dokic, we explored how owning the full stack lets you optimize not just prompts or infrastructure, but the model architecture itself. Huge thanks to them (and the AWS team including our partner in crime Eran Bachar) for an outstanding collaboration over the last three to four years. This paper shows how we did that in practice. We used knowledge distillation to transfer quality from very large teacher models into much smaller students, preserving task performance while dramatically reducing cost and memory footprint. We then applied speculative decoding, using Medusa-style heads to parallelize token generation. Instead of treating inference as a black box, we changed how decoding works under the hood, achieving large speedups without sacrificing output quality. The key insight is that these techniques compound. Distillation makes models smaller and cheaper. Speculative decoding makes them faster. Combined, they delivered 10–20x latency improvements in real production systems like AI Trip Planner, Smart Filters, and large-scale content generation. The bigger takeaway is not a single optimization. Over time, we have built an internal recipe for latency control across open-source LLMs. Distillation. Speculative decoding. Quantization. Task-specific training. KV caching. Careful serving. Once you own this toolbox, you can apply it to almost any task, and tune the speed-quality-cost tradeoff intentionally instead of accepting it as given. This is why open-source models are so powerful in practice. Latency is no longer a constraint you work around. It is a dimension you control. And it is yet another great example of the kind of deep, hands-on GenAI work the team is doing to build fast, reliable, AI-first travel experiences for our customers. (and yes we are hiring in TLV and AMS - ping Moran Beladev for open roles)

44

1 Comment