top of page
Codersarts Blog.
What’s new and exciting at Codersarts
Search


What Is Code Mode MCP? A Different Way for Agents to Use Tools
The usual way an AI agent uses tools is simple. The model picks a tool, the system runs it, the result goes back to the model, and the cycle repeats. It works well for a handful of tools and short tasks. It strains as the number of tools grows. Every tool definition sits in the model's context, and every intermediate result passes through the model on its way to the next step. Code Mode MCP takes a different route. Instead of calling tools one at a time, the agent writes a sm
ganesh90
Oct 2112 min read


How Jev Breaks from the LLM Approach
Most AI systems today are built around one idea: a large language model reads a prompt and writes text, one token at a time. That approach is flexible, and it has shaped how teams think about every AI problem. Many decisions inside business software do not need flexibility. They need a fast, reliable answer to a narrow question, such as which queue a request belongs in or whether a case should be escalated. In September 2026, TypeSafe introduced Jev, a model it describes as t
ganesh90
Oct 2111 min read


When Classic ML Beat an LLM for Our Client
Large language models are impressive, and many teams reach for one first. For a surprising number of business problems, a smaller and older approach does the job better, faster, and for far less money. Classic machine learning means models such as gradient boosted trees, logistic regression, and random forests, trained on structured data for one specific task. They are not glamorous, and in the right setting they are hard to beat. This blog explains when classic ML wins over
ganesh90
Oct 2011 min read


LLM-as-a-Judge: When It Agreed with Humans and When It Didn't
Reviewing AI outputs by hand is slow and expensive. So many teams ask a language model to do the grading. A judge model reads an answer, scores it against a rubric, and moves on to the next thousand. The idea works well in some settings and fails quietly in others. A judge that agrees with your reviewers on easy cases can still miss the mistakes that matter most, and it can reward the wrong things without anyone noticing. This blog explains when an LLM judge tends to agree wi
ganesh90
Oct 2011 min read


Re-ranking in RAG: Was It Worth the Extra Latency?
A RAG system lives or dies on what it retrieves. If the right passage never reaches the language model, the answer will be wrong, however good the model is. Re-ranking is a popular fix. The system retrieves a larger set of candidate passages, then a second model reads each one alongside the question and puts the best at the top. It often improves relevance. It also adds time to every request, and that time is paid by every user. This blog explains what re-ranking does, what i
ganesh90
Oct 2012 min read


Audit Logs for AI Decisions: What to Record and Why
When an AI system makes a decision, someone will eventually ask why. A customer disputes a result, a regulator requests evidence, or a team member wants to know why the assistant behaved oddly last Tuesday. Without a good record, the honest answer is that nobody knows. With one, the question can be answered in minutes. This blog explains what to record in audit logs for AI decisions, why each item matters, and how to store the logs safely. It reflects the approach of the Code
ganesh90
Oct 2013 min read


What We Learned Delivering AI Projects for Clients Around the World
Most AI projects do not fail because the model was wrong. They fail because the goal was fuzzy, the data was not ready, nobody owned the result, or the team and the client stopped understanding each other somewhere between the second and third week. Those problems look the same in every industry and every country. They get harder when the people involved sit in different time zones, speak different languages, and work under different rules. This blog shares the lessons that m
ganesh90
Oct 1611 min read


Handling Personal Data in LLM Pipelines: Masking, Retention and Deletion
A large language model does not need to know a customer's name, address, or account number to answer most questions. Yet personal data finds its way into prompts, documents, logs, and caches, often without anyone deciding that it should. Once it is there, it is copied. A support message becomes a stored trace, a retrieved document becomes an embedding, and a prompt becomes a record at a vendor. Each copy is a place where the data can leak, linger, or be hard to remove. This b
ganesh90
Oct 1612 min read


How We Decide What an Agent Is Allowed to Do Alone
Every team that builds an AI agent reaches the same moment. The agent works in testing, and someone asks whether it can just send the email, issue the refund, or update the record without a person checking first. The honest answer is that it depends, and the dependence can be made explicit. Autonomy is not a switch. It is a set of decisions about which actions an agent may take alone, which need a person, and which it should never touch. This blog lays out how to make those d
ganesh90
Oct 1612 min read


The Hallucination That Reached a Customer: Root Cause and Fix
Sooner or later, an AI system says something false to a real customer. It sounds confident, it looks official, and it was never in any of your documents. The first reaction is usually to blame the model. That is rarely the whole story. Hallucinations that reach customers almost always pass through several weak points: a missing document, a search that returned the wrong passage, a prompt that rewards guessing, and no check before the answer went out. This blog explains how to
ganesh90
Oct 1612 min read


Why Customers Hung Up on Our Voice Bot, and the Three Fixes
A voice bot can look impressive in a demo and still lose callers in the first thirty seconds. Customers do not complain about the language model. They notice the pause before it answers, the way it talks over them, and the moment it says it did not understand for the third time. Then they hang up, and the call center sees the same issue arrive later as an angry call. This blog explains why customers hang up on voice bots and the three fixes that address most of the causes: fa
ganesh90
Oct 159 min read


Why 95% Accuracy Was a Terrible Model: Picking the Right Metric
A model that is right 95 percent of the time sounds excellent, and it is one of the most misleading numbers in machine learning. If only five percent of transactions are fraud, a model that labels every transaction as legitimate is 95 percent accurate and catches nothing. The score looks great while the model is worthless. This blog explains why accuracy fails on many business problems, which metrics to use instead, and how to choose one that reflects the real cost of mistake
ganesh90
Oct 1510 min read


Securing MCP Servers: Auth, Permissions and Audit Logs
The Model Context Protocol makes it easy to connect AI assistants to company systems, and that ease is exactly why security needs attention early. An MCP server can expose databases, files, tickets, and actions to a model that reads untrusted text and sometimes follows it. If the server is open, over-permissioned, or silent, one clever message can turn a helpful assistant into a data leak. This blog explains how to secure MCP servers around three controls: authentication, per
ganesh90
Oct 1511 min read


Small Models vs. Frontier Models on 5 Real Business Tasks
Choosing between a small language model and a frontier model is one of the most expensive decisions in a production AI project, and it is often made on reputation rather than evidence. Frontier models are more capable on hard problems. Small models are cheaper, faster, and easier to run privately. The right choice depends on the task, and most businesses have several different tasks. This blog compares the two on five common business tasks, explains where each tends to do wel
ganesh90
Oct 1510 min read


Why We Replaced Our Multi-Agent System with One Agent and a Script
Multi-agent systems are an attractive idea. Give each task its own specialist, let a manager agent coordinate them, and the design looks like a small company of experts. In practice, many teams find that the company-of-agents design adds more cost, delay, and confusion than it removes. A growing number of them end up replacing it with something much simpler: one agent that handles the judgment, and ordinary code that handles everything else. This blog explains why that change
ganesh90
Oct 1411 min read


Our RAG Bot Was 30% Accurate. Here's the Pipeline That Fixed It
A RAG bot that gets only about three answers in ten right is not rare. It is the normal result when a team connects a language model to a pile of documents, sees a few good demos, and ships. The assistant sounds fluent, so the wrong answers are easy to miss until a customer, an auditor, or an employee acts on one. The good news is that low accuracy in retrieval-augmented generation is usually a pipeline problem, not a model problem, and pipeline problems can be measured and f
ganesh90
Oct 1411 min read


What Is OpenAI Dots? Always-On AI Agents and What You Need to Know
Most AI assistants stop working the moment the conversation ends. You ask, they answer, and the next step waits until you come back. In September 2026, OpenAI introduced dots, always-on agents inside ChatGPT that keep working toward a goal after the chat is over, using their own cloud computer, a browser, and the apps you connect. This blog explains what OpenAI dots are, how they work, who can use them today, which safety controls come with them, the risks enterprises still n
ganesh90
Oct 1313 min read


What Is Jev? Understanding TypeSafe's System One Model
Most enterprise AI systems still rely on a large language model to make decisions that are, at their core, simple: is this invoice valid, does this application meet the criteria, which department should review this document? Using a chat model for these choices works, but it is slow, expensive at volume, and it returns text that software must parse before anything can happen. In September 2026, TypeSafe introduced Jev, the first model in a new category it calls System One, bu
ganesh90
Oct 1313 min read


Why Does MCP Matter for Enterprise AI?
Every enterprise AI project hits the same wall: the model is capable, but it cannot reach the systems where the work happens. Connecting an assistant to a ticketing tool, a document store, a database, and a CRM has usually meant a custom integration for each pairing, rebuilt whenever anything changes. The Model Context Protocol (MCP) is an open standard that replaces this with one common way for AI applications to discover and use tools and data, which is why it is now a prio
ganesh90
Oct 1315 min read


How to Measure Prompt Optimization: Beyond Subjective Evaluation
A prompt that sounds better to the person who wrote it is not the same thing as a prompt that performs better in production. Many teams still judge prompt changes by reading a handful of outputs and deciding which one feels right, but that approach cannot tell whether a change improved accuracy, quietly increased hallucinations, or opened the door to a prompt injection attack. Measuring prompt optimization properly replaces opinion with evidence, and for leaders funding AI pr
ganesh90
Oct 1211 min read


GraphRAG for Enterprise AI: Everything You Need to Know
Most enterprise AI assistants answer questions by finding the passages that look most similar to the question and handing them to a language model. That works well for lookups, but it struggles when the answer depends on how things are connected, such as which systems fail when one service goes down, or what the main themes are across thousands of documents. GraphRAG addresses this by adding a knowledge graph to retrieval, so the system can follow relationships and reason acr
ganesh90
Oct 1210 min read
bottom of page