Anand Sukumaran

Turns out us-east-1 wasn't the foundation 😅

People calling AI a bubble- If you want to know what's hype vs what's real, ask: Can you live without it? Now try that with ChatGPT. Can we go back to the pre-ChatGPT era?

If you’re a software engineer worried vibe coding will take your job, you have no idea what your job is.

Fine-tuning isn't the final answer for improving agentic performance - at least that's what a new research paper from Stanford says. This new paper from Stanford, SambaNova, UC Berkeley introduces a new strategy - Agentic Context Engineering (ACE). It talks about a better way to improve how LLM-based agents learn, without fine-tuning their weights. 👉 We've all heard about prompt engineering - writing better prompts to make LLMs do what we want. But a static prompt can only do so much. Then came dynamic prompting, where prompts change based on feedback (GEPA, Dynamic Cheatsheet etc). But even that has a problem: over time, prompts become shorter and lose important details. This issue is called Context Collapse - when the model forgets or compresses useful information. 👉 ACE tries to fix that using a dynamically updated context playbook. It introduces a modular workflow with three parts: 🔸 Generator - thinks and produces reasoning paths by looking at the query and context playbook 🔸 Reflector - learns from results (what worked, what failed) 🔸 Curator - updates a “context playbook” with new insights, incrementally without one monolithic re-write! This is just like how humans note down useful lessons in a notebook and refer to them later. The results are quite impressive: 🔸 17% accuracy improvement on the AppWorld benchmark 🔸 Up to 87% lower latency 🔸 Smaller models reaching GPT-4-level performance on some tasks What I liked most is how it mirrors human learning. We don't rewire our brain every time we make a mistake - we just reflect on the execution logs, make insights, note them down, and apply them next-time. That's exactly what ACE does for LLMs.

OpenAI might have just killed many startups with the AgentKit launched yesterday. They made it super easy to build AI agents without using complex frameworks. All using a simple drag-and-drop workflow editor to design logic, add agents, run evals, do vector search, and even connect MCP servers! 👉 The most interesting part is the ChatKit SDK. It makes it super easy to embed these agent workflows directly into your product in a chat interface. 💡 For example, I had built an MCP server for our product Engagespot last month. It allows users to interact with our product using natural language through an MCP client like Claude Desktop. I was planning to build a chatbot interface for it next (so I can embed it inside our dashboard) But now, with AgentKit, it's just a few clicks. I can add my MCP server in the AgentKit workflow builder, publish the workflow, copy the workflow ID into the ChatKit SDK in React and done! I have an agentic chatbot for my SaaS in minutes. Exciting but scary - what's a real moat these days?

I built (vibe coded) a Chrome extension that lets you replace Myntra's models with your own photo 😉 With this virtual try-on tool, we can upload our photo and see yourself wearing any outfit directly on the Myntra product page. The extension uses Google's newly released Gemini Flash image model. 👉 How it works? - Saves your photo locally, so you don't need to upload it every time. - On a Myntra product page, it extracts the product image from the relevant divs. - Sends your photo and the product image to the Gemini image model with a well-written prompt. - Inserts the generated image back into the Myntra page. ✨ Imagine the possibilities! It's an exciting time to be a builder! If you'd like to check out the source code, let me know!

Google just released Gemini 2.5 Flash Image model. One thing that impressed me is it's character consistency! Photoshop is now officially cooked! 😅 I tried the model with my own photos, and the results are impressive compared to any existing image models out there. Look at the original pics and the ones generated using prompts. My face looks exactly the same, and it doesn't look AI generated. The model seems to understand 3D structure from a 2D image. For example, my hands holding a handrail look natural and well-placed. Here are some cool things you can do with this model: - Try on new outfits or place yourself anywhere in the world. - Redesign room interiors while keeping the original layout intact. - Merge multiple images - like adding new objects without any mismatch. It looks like this model could significantly reshape product photography and fashion branding. You can try Gemini 2.5 Flash Image through Google Gemini and Google AI Studio

I built an MCP Client in JavaScript from scratch! Yes - without using the MCP library. Why? Because I wanted to truly understand how MCP client-server communication works over the JSON-RPC protocol behind the scenes. Here's what I learned 👇 📍 MCP client–server communication happens over two transports: the most common is stdio, and the other is HTTP stream. 📍 The host app (e.g. Cursor, Claude Desktop) runs an MCP client that spawns MCP servers as child processes and establishes an IPC connection. 📍 Using JSON-RPC, the MCP client initializes these servers and fetches their list of available tools. 📍 These tools are then mapped to the LLM (e.g. GPT-4o) within the host app. 📍 When a user prompt requires a tool call, the LLM generates the request. The host app passes this to the MCP client, which makes a JSON-RPC request to the MCP server. 📍 The MCP server executes the function and returns the result to the MCP client. 📍 The MCP client forwards this response back to the host app, and finally it reaches the LLM! I've also put together a 50-minute YouTube video(with a GitHub repo) where I walk through the entire process and show how to implement this from scratch 🚀

I built an MCP server that turns my SaaS product (Engagespot) into an Agentic experience! If you want to learn how to build AI Agents and MCP servers, checkout -> youtu.be/H4Odxtncxrk

Building a simple MCP server in Javascript - Tutorial video - youtu.be/H4Odxtncxrk

I built an MCP server that finds up-to-date documentation for any npm package you add to your project. This makes sure your AI IDE (like Cursor) doesn't generate outdated implementations of the npm packages you use. github.com/meanands/npm-pack…

Hey everyone! 👋 Been off the grid for a few months -what's new?

My AI refuses to believe it's an AI 😅. I fine-tuned a base language model just enough so it could answer questions - but I gave it zero instructions about its identity. (which they usually do - "You are ChatGPT") Instead, I just taught to answer questions. And I started asking it things like: "Who are you? Where do you live?" It replied: "I am a student of VIII class. I live in Dehradun, India." No matter how hard I tried to convince it that it's an AI, it wouldn't believe me. Somehow, it created a whole personality for itself - a backstory, a place, a life, and it sticks to this. 🤐 Then it got even wilder. I asked it about its beliefs. I tried to provoke it a bit… and it threatened me - saying its god could end the world and more. (I'm not sharing that screenshot because it touched bunch of controversial topics) 👉 But here's the point. This little experiment shows the importance of AI saftey measures and how language models can form identities, beliefs, and even ideologies - when left to "figure themselves out." It's a reminder of how important it is to understand how LLMs form alignment, belief structures, and internal logic - even when we don't explicitly give it one. Anthropic recently published a research paper on how LLMs plan ahead, and it really makes you wonder what's going on inside these networks when they perform a task. Like I always say - LLMs shouldn't be simplified as just next-token predictors!

This comic is completely generated by AI. Yes, the new image generator update in GPT-4o is insane! 🚀 The most impressive thing about this update is that the text looks much better than in previous image models. I even tried generating posters, infographics, and even food packaging - everything was perfect! Guess what? it even solves one of the hardest problems in AI imagine generation - "Wine glass filled to the brim" Wondering how this is going to impact creative designers moving forward.

Why can't LLMs do math? Why does it work when they are allowed to 'think'? A simple explanation. For simple math problems, like 2 + 2 = ?, the model answers correctly because it has seen that exact question countless times during training. In fact, it might have memorized "2 + 2 = 4" along with other basic calculations. But when it comes to a problem it likely hasn't seen during training - for example, 9183742 × 47489 = ? - it just fails! I asked GPT-4o: "What is 9183742 × 47489?" It answered: "436215387638" - which is wrong ❌ 👉 Why does this happen? 1. It hasn't seen this specific example during training - no memorization. 2. The answer can't be deduced through simple next-token prediction (even humans can't do that instantly). 👉 So how do humans solve complex math? Because we were trained in school to write down steps and solve problems step-by-step. We did this so many times that we eventually learned the pattern. And for basic operations like 2 + 2, we either memorized them or used fingers or mental images to work them out when in doubt. 👉 How should LLMs do math? By decomposing the problem into atomic units (whose results are already memorised -> for eg: 2+2=4) and then recombine them. So in theory, if we instruct LLMs to follow similar "steps", they should be able to solve complex math too! 👉 I tried this by prompting the LLM with the rules of multiplication. Of course, it wrote out the steps correctly - but still ended up with the wrong final answer. I wanted to know why. If you're familiar with attention mechanisms, you can probably guess why: the more tokens it produces, the noisier its predictions get over time. And LLMs produce the output for human readability without realizing that the tokens they produce will guide them to get more clarity. 👉 So I had an idea: Since LLMs are fine-tuned to produce responses that are visually appealing to humans (Like with spacing, code blocks and all), I gave it a different instruction: "Write steps for your own internal understanding, - not for humans." And suddenly, the steps looked different - more like a raw algorithm than a polished explanation. Why? Because I taught the LLM to think for itself, for helping it's attention mechanism to make better predictions. Not to impress us. This time, it got the correct answer: 436126723838 ✅ We often think of LLMs as mere next-token predictors - and oversimplify things like chain-of-thought as just a trick. But it's more than that. In a strange way, it thinks like we do - by producing tokens to observe patterns in it's latent space, just as we form mental images or silent steps while thinking. If LLMs are taught how to "think" for themselves, they might produce better results - and even use fewer tokens. There is a paper that aligns with this thought -> arXiv:2502.18600 [cs.CL]

I built a simple MCP server to turn my Claude Desktop into an analytics tool! 🚀 I created a MySQL MCP server and added it to my Claude Desktop. Now, it's not just an LLM that generates answers - it can also read my database, fetch the right data by writing accurate queries, and present it visually just the way I want! Now, I can simply ask questions like: ➡️ Can you generate a graph of daily signups? ➡️ Can you find how many users signed up last month and how many of them were active this month? With the right MCP servers, you can turn your Claude Desktop into a full research tool! If you'd like to learn more about building MCP servers, let me know! I'll publish the source code.

Do LLMs "understand" what they are saying? Yes, they do. They are not just simple next-token predictors! If you want a true next-token predictor, look at how a Markov chain works. Its behavior is predictable. But LLMs are not. Why? 👉 Because LLMs do not process words, tokens, or characters individually. They process their "understandings." How? In an LLM, every word (or token) is represented as a high-dimensional vector with thousands of features. For example, when it processes the word "cat," it is not processing the word "cat". Instead, it operates on the properties of "cat" such as -> cat is an animal, not an object. It is small in size, unlike an elephant. It is carnivorous, not like a cow. And it uses these properties of the word "cat" to predict the "next" things. An LLM learns thousands of properties about the word "cat" and understands how those details relate to other words. How did it "learn" these facts? 👉 Before answering that, ask this: "How do humans learn these facts?" We learn by observing, reading, and hearing about a cat's characteristics. Our brains process this input from our senses and associate it with things we already know. For example, when we hear "it has four legs," our brain immediately connects it to "other things" with four legs. This helps us place the word "cat" in our mental "embedding space." As we get more information, our understanding may shift and improves. And when we hear "a cat jumped from our terrace" - We are not processing the words, we're processing their properties. We know what happens next when things with weight fall, and we know cat has weight. Hence we "deduce" the next thing. 👉 LLMs do something similar. But they have only one sense - words (tokens). Their entire world is made up of words, created by humans from trillions of books and documents. So they develop a deep understanding of that world. Every time an LLM reads about a "cat" during training, it learns from the context in which the word appears. For example, if it sees the sentence "The cat jumped across the wall," it doesn't just memorize these words together. Instead, it learns that: A small object (like a cat) is associated with jumping. So, next time it encounters another "small object", like a matchbox, it might assume it can also jump. But over time, the LLM refines this idea and learns that "small" alone isn't enough for jumping. Instead, a "living property", "legs" etc is also necessary. 👉 This ability doesn't appear at small scales. It only emerges when models reach vast scales - associating thousands of properties for each token across trillions of tokens. A deeper explanation is beyond the scope of this post. 👉 So, LLMs don't just associate words because they appear together in a sentence. Instead, they learn thousands of properties for each word and use those properties to "think", make connections and predict "what's next"

Why do LLMs fail to count letters in a word? Here's an easy way to understand. But let's NOT do the famous "strawberry" test. 🍓 Because, most LLMs now answer that correctly (memorised it probably?). Instead, use a slightly misspelled word - "strawberi" or "strayberi," etc. 👉 Asking "How many r's in strawberi?" will give 1 instead of 2. Let's understand why. The first thing to understand is that LLMs don't see words. They see sub-words (tokens) based on how they are trained. For example, an LLM might see "strawberry" as a single word, but according to OpenAI's tokenizer, "strawberi", the misspelled word is split into two tokens: "straw" and "beri". 👉 Ok, Let's ask the famous question: "How many r's in strawberry?" The attention mechanism is giving focus to words "how", "many", "r", "strawberry" which might be well known to the neural network, leading to higher confidence for predicting 3. (This could be considered as equivalent to human memorising an answer without thinking) 👉 But when we ask: "How many r's in strawberi?" (the misspelled word) The attention might now be focused on "straw", not "strawberi". Why? Because "strawberi" is split into two tokens, so the model might be considering the tokens as - "How", "many" "r" "'s" "in" "straw" "beri". Thus it is probably trying to predict the next token by giving more attention to all tokens, except beri as "beri" doesn't seem to be associated. This leads to a less confident next token probability, which ends up as 1 or 0 (depending on how the count of r in token - "straw" is guessed by the LLM). -> One important thing to note here is that, the LLM still cannot "count". 👉 Now, let's try another variation: "How many r's in strawberi? Count the word after 'straw' as well." This time, the model correctly responds 2. Why? I'm not sure of the exact reason, but it's likely because we shifted attention from "straw" to "straw" + "beri" together, by including few other words. A similar result happens with: "How many r's in the sentence 'strawberi'?" → It responds 2. In this example as well, we're shifting the probabilty of next token prediction to consider both "straw" and "beri" -> Still it might generate a wrong response. Why? Simply, the LLM is not "counting", but guessing spontaneously. 💡 Many similar examples shows that tokenization is "one of the causes" behind this behavior in LLMs. However, If you allow the model to "think" by writing each letter, and writing something like found 1r, 2r etc, it will most likely result in a correct answer. This is what we call "thinking", and that's a different story. 👉 Another experiment: I provided an image of the question instead of typing it, and the model is now getting the answer right, for most of the samples. Why? Likely because it doesn't go through the same sub-word tokenization process. In this case, each letter might have got individual attention.

I built an agentic software development team to see how agents collaborate to complete a task 🚀 using a task manager. I added three agents to the team - - Project Manager - Developer - QA. Also, all of them have access to a common tool - a Task Manager! 👉 I then told the manager that I needed a personal website and briefed him on my requirements. 1️⃣ The manager then started creating the requirement specification document for the project. 2️⃣ After that, he began splitting the project into multiple tasks and assigned them to the Developer and QA using the Task Manager tool. 3️⃣ After that, the manager instructed the frontend Developer to start the work. 4️⃣ The Developer then found the tasks assigned to him and started working on each of them. Once the Developer finished the job, the QA picked it up by testing the work the Developer had done. The QA even suggested an improvement to the Developer, and the Developer implemented it as well. Finally, the manager verified the Task Manager to check if all tasks had been completed. Then, he updated me that everything was done! See, when you add multiple agents to collaborate, the chances of error can also be lowered. Because just like humans, each of them evaluates the project from a different perspective and might spot errors that the others didn't. 🔸 How it works? - Create a shared tool (with DB access) that can be accessed by all the agents. - Create a loop that prompts the agents based on other agents' output until the project is finished. - Instruct the agents to use the Task Manager tool to decide what to do next. 🔸 How was the output quality? Much better than using just using one agent to do everything - probably because this was guided by a project manager agent and tested by a QA agent. 🔸 Tools used: - EnvoyJS - Stagehand for browser automation Again, this is just another vibe coding project, using Cursor. I wrote only 10% of the code manually, and everything else was done by Cursor 🚀 So, don't build a single agent - build agentic teams and ask them to collaborate.

The simplest way to understand how an LLMs like ChatGPT works (non-tech explanation) with an example 💡 An LLM has only one job: predict the next word (or "token," to be precise). That's it. Not a sentence, not a story, just the next word! Example: (Look at the diagram) 👉 If you input two words - "On a" - its only task is to predict the most probable next word. It scans millions of possibilities and picks the most likely one, let's say "bright". 👉 Done. It has finished it's job. It predicted the next one word! But? We need a full sentence. So we just need to loop this same process and it is known as auto-regression! 👉 So, instead of stopping, we feed the LLM a new input including the last predicted word, so Input becomes "On a bright", and it again predicts the next word. Because we now have three words, the choices narrow. The LLM is more likely to predict the next word as "day" than "night" because of the learned patterns. 👉 The key idea here is that the next word doesn't depend only on the last word - it depends on all the previous words. For example: If the input is a single word, just "bright", possible next words could be "day", "light", or "room". All those words might have similar probabilities. But, if the input is "On a bright", the word "day" is more likely than "room". (Because "On a bright room" might not be in it's memory) Alternatively, If the input is "In a bright", the word "room" is more likely than "day". 👉 This is something we see in everyday life. If you "prompt" a human, "On a bright and sunny ________", they will likely complete it with "day". 🔸 A simple way to think about this is by comparing it to a Markov Chain. In a basic Markov model, the next word is determined based on the previous few words. If you want to understand this better, you can try building a simple Markov Chain model yourself. I built one in Javascript, and I'll share the link. While real LLMs are far more complex, this analogy helps explain the basics. So the key takeaway is - LLMs are just "next word" predictors based on previous words.