9 Agentic AI terms

Picking the model is the easiest part of building an AI agent. The 9 layers around it decide whether it works in production:

1. Harness: The loop that lets a model act. Context in, tool call out, result back, repeat
2. Memory & state: What it remembers between runs, and where it is in the task right now.
3. RAG (retrieval-augmented generation): Pulls the right docs into the prompt so answers come with sources.
4. MCP (Model Context Protocol): One standard plug for tools and data. It now lives at the Linux Foundation.
5. Skills: Reusable know-how in a SKILL.md file. Only the name and description load until a task needs it.
6. Guardrails: Permissions, sandboxes and a human sign-off before anything risky.
7. Evals: Scores outputs against what you expected, before your users do it for you.
8. A2A (Agent2Agent): How agents from different vendors find each other and hand off work.
9. Multi-agent: An orchestrator splits the job. Specialists run in parallel.

MCP, A2A and Agent Skills are all open standards now, so what you build on them isn't stuck with one vendor. Save this for your next agent build. Which layer is your team skipping right now?

Weight Management in Ladies

Ladies, weight management is also a skill. And skills take practice. Buying new walking shoes is an excellent beginning, but unfortunately, the shoes cannot do the walking.

Three things to start with

1. Fasting
2. Training
3. Feasting

The ambition isn’t to look exactly as you did at 25. Your body has lived through a few chapters since then. Let’s work towards strength, health and habits that suit your life today.

1. Understand fasting before attempting it.

Upvaas deserves more thought than deciding how many hours you can tolerate hunger.

Whether fasting suits you depends on your health, medicines and nutritional needs. It is optional, and longer does not automatically mean better.

Please don’t attempt a 9–10-day fast on your own. Prolonged fasting needs medical assessment and supervision, especially if you take insulin or diabetes medicines.

2. Learn to train with curiosity.

Walk complete. Attendance marked. Kal phir milenge.

Consistency matters. But gradually ask a little more of yourself.

1. Can I walk the same distance with less effort?
2. Can I lift with better technique?
3. Has my balance improved?

Whether you enjoy walking, yoga, cycling or the gym, notice what your body is learning. There is considerable satisfaction in discovering that something difficult last month feels manageable today. Give yourself the chance to enjoy that.

3. Learn to feast with awareness.

Celebrations will happen. Favourite foods will remain favourite foods. And some evenings, your mood will nominate the kitchen as its grievance department. Pause and notice what you need. Hunger? Comfort? Rest?

Enjoy your food, pay attention to portions and give fullness a chance to register. You don’t have to earn dinner through exercise or compensate for it by fasting tomorrow. My father used to say that digging ten shallow holes won’t get you water. You have to stay in one place and dig deeper. I think of that whenever someone abandons a routine before they have had time to learn it. Spend the coming year getting better at caring for your body. There is more to learn than how to make the weighing scale cooperate.

3 Markers for pre-diabetes detection

Three markers that detect early signs of Prediabetes. And once you catch them early reversal becomes far more achievable.

Most people wait for their sugar levels to show up. But by that time, the real damage has already begun to the Pancreas, Liver, and Heart. The earliest red flags often show up in places we rarely check.

Here are the 3 tests I recommended for early detection

1. Fasting insulin
2. Liver function tests (SGPT, SGOT)
3. Cholesterol ratios (not just the total number)

These give us a head start. They convey the warning signs before sugar starts to show up in medical reports.

Don’t just keep an eye on your sugar. Understand what's going on behind the scenes!

Claude 5.5 vs GPT-6: The AI cage match nobody asked Finance about

The AI model race has officially reached the point where product launches are beginning to resemble calendar collisions. On September 22, 2026, Anthropic introduced Claude Opus 5.5, while around the same time OpenAI expanded its GPT-6 family with GPT-6 Sol and GPT-6 Luna. Three new names, two companies, and an increasingly crowded AI landscape, but this is not really a story about three models fighting for the same job.

The more interesting story is what these releases tell us about where AI is heading: increasingly capable models, increasingly specialized tiers, falling inference costs, longer-running agents, and a growing realization that the smartest model is not necessarily the model you want handling every task. Claude Opus 5.5 and GPT-6 Sol are particularly interesting because they target substantial professional workloads, while GPT-6 Luna occupies a different part of the market, emphasizing efficiency and high-volume processing. The useful question, therefore, is not simply which model is better, but what kind of work each model is being built to do.

Claude Opus 5.5 is positioned by Anthropic as its latest high-end model for complex work, particularly long-running agentic coding and knowledge-intensive tasks. With a 1-million-token context window and support for up to 128,000 output tokens, the model is designed for a very different kind of interaction from the traditional chatbot experience.

The next generation of AI applications increasingly won't look like a user typing a question and receiving a paragraph in response. Instead, AI systems will be expected to work for extended periods: reading large codebases, examining documentation, making changes, running tools, evaluating results, revising their work and continuing until a broader objective has been completed. That is a fundamentally different workload from ordinary chatbot interaction.

Anthropic says Opus 5.5 delivers major improvements on complex work while requiring substantially less compute than its predecessor, while also improving communication and making long sessions clearer and easier to follow. That latter point may sound cosmetic, but it becomes important when humans are collaborating with AI for hours rather than seconds. A model can produce technically strong output, but if the person supervising it struggles to understand what it is doing, why it is doing it, or where it is in a process, much of that productivity advantage can disappear.

Opus 5.5 is therefore being presented as something closer to a persistent digital collaborator than simply a smarter chatbot, a system capable of taking on substantial pieces of knowledge work and remaining engaged with them over time.

GPT-6 Sol approaches much of the same professional market from a somewhat different direction. OpenAI positions Sol as a model for demanding everyday work, including coding, complex workflows, computer use and analysis that requires meaningful reasoning without necessarily requiring the maximum capability of the GPT-6 family.

That makes Sol particularly relevant to organizations attempting to deploy AI throughout an enterprise. Consider a typical technology organization: there may be highly specialized architectural problems that justify using the most capable model available, but there are also thousands of smaller engineering tasks taking place every day, debugging, code review, documentation, refactoring, test generation, data analysis and routine feature implementation. Those tasks don't disappear simply because a company has access to a flagship model. In fact, they become increasingly attractive targets for automation.

Sol is designed to operate in that space. OpenAI also says GPT-6 Sol makes roughly half as many mistakes as its GPT-5.6 predecessor on its internal factuality evaluation, while emphasizing improvements in coding and computer-use capabilities. That combination is significant because the AI industry's focus is gradually shifting from a relatively simple question, "Can the model answer this?", toward a much harder one: "Can the model actually complete this task without constant supervision?"

Those are very different propositions, and the latter is where much of the commercial value of AI may ultimately reside. And Then There Is Luna

GPT-6 Luna makes the comparison even more interesting because it isn't positioned as a direct substitute for Opus 5.5. Instead, Luna is built around a different economic proposition: high-volume workloads with relatively clear objectives, such as summarization, extraction, classification, routing and other repetitive operations where speed and cost matter enormously.

That may sound less exciting than an agent migrating a massive software project, but economically it could prove just as important. Imagine an enterprise processing millions of documents, classifying customer requests, extracting structured information from contracts, routing support cases or generating summaries across thousands of internal records. These workloads don't necessarily require the deepest reasoning available for every request. What they need is a system that is fast, dependable and inexpensive enough to operate continuously.

That is Luna's territory, and it reflects an increasingly mature AI market. The question is no longer simply how intelligent a model can become. It is also how cheaply that intelligence can be deployed at scale.

Pricing may ultimately be one of the most consequential differences between these new releases. Claude Opus 5.5 is priced at $4 per million input tokens and $20 per million output tokens, with Anthropic saying the model costs around 40% less to operate than Opus 5 on typical workloads and that cache reads are substantially cheaper as well. GPT-6 Sol and Luna take a different approach, with OpenAI announcing pricing roughly half that of its GPT-5.6 promotional pricing for the corresponding models.

The individual numbers matter, but the broader trend matters even more: AI inference is becoming cheaper. And when inference becomes cheaper, developers can build applications differently. They can make more model calls, introduce additional verification steps, give agents more intermediate actions, process larger volumes of information and combine several models instead of forcing one expensive model to handle everything.

In other words, lower inference prices don't merely make existing AI applications cheaper. They expand the universe of applications that make economic sense in the first place.

Another striking commonality is context. Claude Opus 5.5, GPT-6 Sol and GPT-6 Luna are all positioned around very large context windows, with the models capable of handling roughly one million tokens of context. That changes the way developers can approach complex information because applications can increasingly give models much larger working sets instead of constantly summarizing, chunking and retrieving information from enormous collections of material.

For software development, that could mean providing substantially more of a repository. For research, it could mean working across larger collections of documents. For enterprise applications, it could mean giving an agent far more operational context before it begins acting.

A larger context window, however, should not be confused with perfect understanding. The ability to ingest a million tokens does not mean a model will automatically identify every important relationship within them. The real value comes from combining large context with strong reasoning, retrieval, tool use and thoughtful application architecture. The window is getting bigger, but the engineering challenge hasn't disappeared; it has simply moved.

If there is one area where these releases appear particularly consequential, it is software engineering. Claude Opus 5.5 is explicitly designed for long-running agentic coding and knowledge work, with Anthropic highlighting an early tester completing a 680,000-line code migration in less than a day. GPT-6 Sol, meanwhile, is being positioned heavily around coding, debugging, refactoring, computer use and multi-step workflows.

That tells us something about where AI companies believe some of the next major productivity gains could come from. The future isn't necessarily an AI that simply writes a clever function from a prompt. It is an AI that can enter a repository, understand the architecture, identify a problem, modify multiple files, run tests, interpret failures, make corrections and ultimately produce a working result.

That is much closer to software engineering than autocomplete, and it places greater value on persistent context, tool use, planning, verification and reliability. The model that writes the best individual function isn't necessarily the one that creates the most value for an engineering organization. The bigger prize is completing the workflow.

Claude Opus 5.5 and GPT-6 Sol overlap considerably more than either does with Luna. Both are aimed at substantial professional work, emphasize coding and complex reasoning, support agents and multi-step tasks, and offer enormous context windows. Their product philosophies, however, are not identical.

Anthropic is placing considerable emphasis on long-running agentic work, communication quality and safety systems surrounding highly capable models. OpenAI is presenting Sol as part of a broader GPT-6 family, emphasizing the ability to bring much of the flagship generation's capabilities into a faster and more economical model.

That distinction matters because Anthropic's pitch is strongly centered on the model as a long-running collaborator, while OpenAI's approach positions the model as a scalable component within a broader family of intelligence. Neither philosophy necessarily excludes the other. In fact, production AI systems may eventually combine both approaches, using different models according to the demands of a particular workflow.

Comparing Opus 5.5 directly with Luna is somewhat like comparing a professional power tool with a high-speed industrial conveyor belt. Both can be extremely useful, but they solve fundamentally different problems. If an organization needs an agent to reason through a complicated software problem, a high-end model may justify its cost. If that same organization needs to classify ten million documents, the economics look very different. This is why model families are becoming increasingly important.

The future is unlikely to involve a single model sitting behind every application. Instead, we may see a hierarchy in which a request arrives, the system determines what kind of work is required, a lightweight model handles routine tasks, a mid-tier model tackles more complex work, and a frontier model takes on genuinely difficult problems. The intelligence layer itself becomes an orchestration system.

At that point, the question is no longer simply which AI model is "winning." It becomes a question of how intelligently the work is being routed.

For enterprise technology leaders, this may be the most important takeaway from these releases. Competitive advantage is increasingly unlikely to come simply from having access to the latest model. Most major organizations will eventually have access to multiple powerful systems. The differentiation will come from how those systems are integrated into business processes.

A company might use a high-end reasoning model for strategic analysis, Sol- or Opus-class systems for engineering workflows, and Luna-like models for high-volume processing. The application becomes the intelligence layer, while the models become increasingly interchangeable components within it.

That could make AI architecture look increasingly similar to cloud architecture. Nobody asks which server is "the best server" for every workload; different workloads use different resources according to their requirements. AI appears to be moving in the same direction.

There is another dimension that shouldn't be overlooked. Anthropic has placed substantial emphasis on safety evaluation around Opus 5.5, including external testing and safeguards designed for its most capable systems, while OpenAI is also emphasizing improvements in alignment and reliability across GPT-6 Sol and Luna.

This matters because increasingly autonomous AI systems create a different category of risk from ordinary chatbots. A chatbot producing an incorrect paragraph may be frustrating, but an agent incorrectly modifying production infrastructure could have much more serious consequences. As these systems become increasingly capable of taking actions rather than merely generating text, tool permissions, sandboxing, monitoring, validation and human oversight become increasingly important.

Model intelligence and application safety therefore have to evolve together. The most useful model for an enterprise isn't simply the one that produces the most impressive demo; it is one that can be deployed within the organization's technical, security and governance requirements.

The most interesting development isn't that Anthropic released Opus 5.5 while OpenAI released Sol and Luna within hours of one another. It is that both companies appear to be converging on the same broad reality from different directions.

AI models are becoming more capable, context windows are becoming enormous, agents are becoming more practical, coding is emerging as a primary use case, inference is becoming cheaper and model specialization is becoming increasingly important. The old AI question was relatively straightforward: "How smart is the model?"

The new question is considerably more useful: How much valuable work can this model actually complete, at what cost, and with what level of supervision? That is a harder question to answer, but it is also much closer to the question businesses ultimately care about.

The bottom line is Claude Opus 5.5, GPT-6 Sol and GPT-6 Luna shouldn't be viewed simply as three entries on a single leaderboard. They represent three different approaches to deploying increasingly capable AI. Opus 5.5 is aimed squarely at sophisticated, long-running agentic and knowledge work. GPT-6 Sol occupies the demanding everyday-work layer, combining substantial reasoning and coding capabilities with a stronger emphasis on efficiency. GPT-6 Luna pushes toward the other end of the spectrum: high-volume intelligence where cost, speed and throughput can matter as much as raw reasoning power. And that may be the real story.

The AI industry is gradually moving beyond an era in which every new release is simply described as "a smarter chatbot." We are entering an era where AI increasingly becomes infrastructure: models for thinking deeply, models for working continuously, models for processing millions of routine tasks, models for coordinating other models, and eventually systems that decide which model should handle which task without the user ever knowing what happened behind the scenes.

The defining advantage of the future may therefore not belong to the model with the flashiest benchmark. It may belong to the ecosystem that can make the right amount of intelligence available at the right price, with the right level of reliability, precisely when the work needs to get done.

Meanwhile, somewhere in a product meeting, someone is probably still asking whether they really need another AI model. The industry's answer appears to be: Absolutely. We have three more coming next week.

#AI #ArtificialIntelligence #OpenAI #GPT6 #ChatGPT #Claude #Anthropic #ClaudeOpus #GenerativeAI #LLM #AIEngineering #EnterpriseAI #AIAgents #Coding #FutureOfWork

Agentic Architectures

Everything you need to know about agentic AI architectures in one visual. 6 shapes to know before you build anything that acts on its own.

1. Code-act agents: These generate and run code themselves, pairing reasoning with actual computation.
2. ReAct agents: They think, act, and observe on repeat, sharpening each move based on what came before.
3. Agentic RAG: Beyond fetching documents, this plans the search itself, weighs which sources deserve trust, and pulls it all into one coherent answer.
4. Tool use via MCP: A shared protocol letting an AI system reach out to external tools without a custom connector every time.
5. Self-reflective agents: They review their own output, spot where it fell short, and adjust before the next attempt.
6. Multi-agent systems: Several specialised agents coordinating and passing information back and forth to handle something too large for one.

Understanding these architectures is one thing. Building with them is another.

The cheaper AI trap: Hello, Jev

There is an interesting paradox emerging in the world of artificial intelligence. We have spent enormous amounts of time and money making Large Language Models more capable, more efficient and, importantly, cheaper to operate. Every generation of hardware, model architecture and inference optimization seems to push the cost of producing useful AI output lower. Quantization, caching, smaller specialized models, better inference engines and increasingly efficient accelerators are allowing organizations to get significantly more intelligence from every dollar spent on compute.

The intuitive assumption is that this should eventually mean we spend less on AI. If something becomes cheaper to produce, surely we should need less money and infrastructure to produce the same amount of it. And in some individual workloads, that is exactly what happens. A task that previously cost a dollar might now cost ten cents, and an organization can quite reasonably celebrate a 90 percent reduction in its inference bill.

But there is another possibility, and it has a rather old name: Jevons' paradox.

In the nineteenth century, British economist William Stanley Jevons observed a counterintuitive relationship between efficiency and consumption. Improvements in the efficiency with which coal was used did not necessarily reduce overall coal consumption. Instead, greater efficiency made coal-powered technologies more economical, encouraged wider adoption and opened up new applications. As the cost of using the resource fell, demand for that resource could increase enough to offset, or even exceed, the original efficiency gains.

More than a century later, the same economic logic is becoming relevant to AI.

Imagine an organization that currently spends $100 to process a particular workload using an LLM. The engineering team optimizes the application, moves some requests to a smaller model, introduces prompt caching, quantizes the model and improves its inference infrastructure. Suddenly, that same workload costs $20. From a purely efficiency perspective, this is an enormous success.

The interesting question is what the organization does with the $80 it has effectively saved.

It could simply pocket the savings. But there is another, arguably more natural, response: use AI for more things.

Perhaps the company previously analyzed only its most important customer interactions because processing every conversation was too expensive. With inference costs dramatically lower, it can now analyze all of them. Instead of reviewing a small percentage of documents, it can process the entire document repository. Software teams can introduce automated code review across every pull request. Customer-service organizations can analyze every interaction rather than sampling a few. Legal teams can screen contracts automatically. Finance teams can continuously examine transactions for anomalies.

The organization has become more efficient, but it has also increased the amount of intelligence it consumes.

That is the part of the AI story that makes Jevons' paradox particularly interesting. Lower inference costs do not merely make existing AI workloads cheaper. They change the economics of what is considered worth doing in the first place.

A workload that was economically unreasonable yesterday can become perfectly reasonable tomorrow.

This distinction is important because AI has an unusually large backlog of potential workloads waiting behind cost barriers. There are millions of documents that nobody previously had an economic reason to analyze. There are countless customer conversations that were too expensive to summarize individually. There are software repositories where reviewing every line of code manually would be impractical. There are business processes that could theoretically benefit from continuous monitoring but were historically limited by the cost of human attention.

When the cost of intelligence falls, some of those previously uneconomic activities become viable.

And this is where the AI industry starts to encounter a fascinating contradiction. The technology becomes more efficient at the same time that society finds more things for it to do.

The transition from traditional AI assistants to AI agents makes this effect even more pronounced.

A conventional software application generally waits for something to happen. A user clicks a button, submits a request or initiates a workflow, and the system responds. Generative AI introduced a more conversational model of interaction, where a person asks a question and the model generates an answer.

Agents take the concept considerably further. An agent can monitor a system, inspect information, reason about what it sees, call other tools, take an action and then evaluate the result. Instead of responding to a single human prompt, it can participate in an ongoing business process.

That changes the economics of inference.

Consider a procurement agent responsible for monitoring inventory and supplier activity. If every model call is expensive, the system might check the environment periodically and perform only a handful of reasoning steps. If inference becomes dramatically cheaper, the organization can afford to make the system much more proactive. It can monitor inventory more frequently, compare more suppliers, analyze more documents, investigate more anomalies and perform more reasoning before escalating an issue to a human.

The cheaper inference becomes, the more attractive continuous intelligence becomes. The irony is that the efficiency improvement can therefore create additional demand for compute. A system that once needed five model calls to complete a task might eventually use twenty or fifty because the marginal cost of those additional calls is low enough to justify them. That does not mean the additional calls are wasteful. They may create genuine business value. The important point is simply that efficiency changes behavior.

An inexpensive intelligence layer can become embedded in places where intelligence was previously absent. The AI infrastructure industry provides a particularly visible example of this dynamic. Data-center operators and chip manufacturers are investing heavily in improving the efficiency of AI computation. New generations of accelerators can perform more operations, inference software can make better use of hardware, models can be compressed and optimized, and memory requirements can be reduced. At the level of an individual inference, the industry is becoming substantially more efficient.

Yet the demand for AI infrastructure continues to expand because the number and complexity of workloads are expanding at the same time.

The reason is not difficult to understand. When AI inference becomes cheaper, organizations can deploy AI in more places. A company that once operated a handful of AI-powered applications can begin embedding models into customer service, software development, cybersecurity, document processing, analytics, search, marketing and internal operations. Applications that were previously constrained by cost can move into production, while existing applications can process larger volumes of information.

This creates a somewhat counterintuitive situation in which improving the efficiency of AI infrastructure can contribute to greater overall demand for AI infrastructure.

The same phenomenon can appear at the application level. Suppose an enterprise reduces the cost of processing a customer interaction by 90 percent. If it continues processing exactly the same number of interactions, the company receives a substantial cost saving. But if that reduction makes it economical to analyze every conversation, generate personalized follow-ups, perform quality analysis and continuously identify emerging issues, the number of model calls may increase many times over.

The cost per inference falls while the number of inferences rises.

Both statements can be true simultaneously.

It would be a mistake to interpret Jevons' paradox as an argument against improving AI efficiency. Making inference cheaper is unquestionably valuable. Lower costs allow smaller companies to access sophisticated capabilities, enable new applications and make previously impractical forms of automation possible.

The real challenge is managing the demand that efficiency creates.

This is where AI architecture and governance become increasingly important. Instead of sending every request to the most powerful and expensive model, organizations can introduce intelligent routing. Simple tasks can be handled by smaller models while complex reasoning is reserved for more capable systems. Frequently repeated requests can be cached. Long-running agents can be designed to avoid repeatedly processing information they already understand. Models can be quantized or distilled where the reduction in capability is acceptable for the particular task.

These techniques are not simply about reducing an AI bill. They are about ensuring that the additional AI consumption created by falling prices is directed toward useful outcomes. That distinction will become increasingly important as organizations move from experimenting with AI to operating it at scale.

The question will gradually shift from "How many tokens are we using?" to "What are those tokens accomplishing?"

A token is a technical unit of consumption. A completed workflow, resolved customer issue, detected fraud event, approved claim or successfully reviewed piece of code is a business outcome. The latter is what organizations ultimately need to optimize. Traditional cloud optimization has generally focused on infrastructure utilization. Teams ask whether servers are appropriately sized, whether storage is being used efficiently and whether workloads can be moved to less expensive infrastructure.

AI introduces another dimension: the possibility of unnecessary reasoning.

An AI agent that makes fifty model calls to complete a task that could reasonably be completed with five is not necessarily more intelligent. It may simply be taking advantage of the fact that inference has become inexpensive.

This creates an interesting architectural challenge. As model calls become cheaper, developers can easily add another reasoning step, another verification pass, another summarization stage or another agent to the workflow. Individually, each addition might look insignificant. Across millions of transactions, however, those small decisions can become a substantial infrastructure bill.

The danger is therefore not simply that AI will be expensive. It is that AI will become cheap enough that nobody notices the consumption growing. That is perhaps the most important connection between LLM economics and Jevons' paradox. When something is expensive, people naturally ration it. When it becomes cheap, they stop worrying about every individual unit. Eventually, the aggregate becomes important again.

There is a deeper implication here. For most of human history, intelligence has been an expensive resource because intelligent work required human time. A person could read only so many documents, investigate only so many transactions and answer only so many customer questions in a day.

LLMs introduce the possibility of making certain forms of cognitive work abundant.

That is an extraordinary economic shift. But abundance changes behavior. When intelligence becomes inexpensive, organizations begin asking whether more processes should be intelligent. Should every document be summarized? Should every customer interaction be analyzed? Should every software change be reviewed? Should every transaction be checked? Should every internal meeting have an AI-generated summary and action plan?

At some point, the question is no longer whether AI can perform the task. It becomes whether performing the task creates enough value to justify the additional computation.

This is why the future of AI economics may not be determined solely by how quickly inference costs fall. It will also depend on how effectively organizations decide where intelligence should be deployed.

The most useful way to think about LLMs and Jevons' paradox is not that cheaper AI will inevitably produce higher consumption. That outcome depends on demand, elasticity, adoption and the economics of individual applications. The more useful lesson is that efficiency and total consumption are different measurements.

An organization can dramatically reduce its cost per inference while simultaneously increasing its total inference consumption. It can become much more efficient and still require more compute. These outcomes are not contradictory.

In fact, they can reinforce each other. The cheaper AI becomes, the more economically attractive it becomes. The more attractive it becomes, the more places organizations find to deploy it. The more places it is deployed, the greater the aggregate demand for inference can become.

That is why the LLM revolution should not be viewed purely through the lens of model capability or token pricing. The more interesting question is what happens when intelligence becomes cheap enough to be embedded everywhere. We may discover that the scarce resource is no longer access to intelligence itself. Instead, the scarce resource may become our ability to decide where additional intelligence actually creates value.

And that is the real lesson from Jevons for the LLM era: making intelligence cheaper does not necessarily mean we will use less of it. It may simply mean that we finally have an economic reason to use it everywhere.

#AI #LLM #GenerativeAI #JevonsParadox #AIInfrastructure #Inference #AIOps #FinOps #AgenticAI #EnterpriseAI

Eating well

Eating well shouldn’t feel this confusing. What should I eat when I’m hungry?

And what if it’s mealtime, but I’m not hungry? I understand the confusion. After hearing so many rules about what to eat, avoid and restrict, even a simple lunch can feel like a difficult decision.

Here’s where I start. Your body needs nourishment every day. The portions you need can vary with your activity, health and routine. A day at your desk may look different from a day of strenuous exercise. But your body still needs nourishment on both days.

When you’re hungry, think about what would make a satisfying meal.

• A source of protein.
• Vegetables or fruit.
• Fiber-rich foods.
• Portions that suit your needs.

And if you regularly reach mealtimes without feeling hungry, look at the pattern. What did you eat earlier? Were you snacking between meals? Has your appetite changed?

That gives us more to work with than a blanket rule to eat or skip a meal. I want people to feel comfortable noticing hunger and fullness, without turning every meal into a calculation. And please remember: you don’t have to earn your food through exercise.

Start with a few balanced meals that fit your day. A familiar routine can make everyday food decisions easier.

Fat: that you cannot see

Over the last two years, one topic that has stayed with me is the role of Liver and Pancreatic fat in type 2 Diabetes. Let me explain. You may know someone who weighs more than you but doesn’t have diabetes. Meanwhile, you’ve been diagnosed despite being relatively slim.

One explanation is our Personal Fat Threshold. Each of us has a different capacity to store fat beneath the skin. When that capacity is exceeded, fat can accumulate in organs such as the liver and pancreas.

This can affect how the liver responds to insulin and, in susceptible people, how well the pancreas produces it. That is why I encourage you to look beyond your weight. Where your body stores fat matters too. The encouraging part is that - Reducing excess organ fat through sustained weight loss can help some people achieve type 2 diabetes remission.

But there is no fixed formula where removing a certain number of grams guarantees remission. Your response also depends on how well your insulin-producing cells can recover. And please don’t read this post and start a 48–72-hour fast on your own.

Prolonged fasting is not essential for remission. Any fasting plan needs a discussion with your treating doctor, especially if you take diabetes medication. What I want you to take away is this - Being slim does not rule out type 2 diabetes, and your care needs to look beyond the weighing scale.

GPT-6 Sol & Luna: same AI family, smaller wallet damage

The AI world barely had time to get acquainted with GPT-6 Astra before OpenAI expanded the family. On September 22, 2026, OpenAI introduced GPT-6 Sol and GPT-6 Luna, positioning them as faster, more affordable members of the GPT-6 generation. If Astra represents the high-end model for demanding work, Sol and Luna are designed to bring much of that capability into the far larger universe of everyday workloads. And that distinction is important.

The most interesting part of this release is not simply that OpenAI has introduced two more models. It is that the company is pushing the GPT-6 generation toward something businesses have been asking for, for years: capable models that can be used extensively without making every API call feel like a conversation with the finance department.

GPT-6 Astra arrived earlier this month as OpenAI's flagship model for complex reasoning, coding, research, computer use and multi-step professional work. Sol and Luna take a different approach. GPT-6 Sol sits in the middle of the family, aimed at demanding everyday work where reasoning quality matters but the absolute maximum level of model capability is not always necessary. GPT-6 Luna moves further toward speed, efficiency and high-volume workloads.

Think of it less as having one giant hammer and more as finally having a toolbox. You probably do not need the largest model in existence to summarize a support ticket, classify a document, extract information from thousands of records, generate routine code, transform text, or power an internal workflow. Using a frontier model for every one of those tasks can be technically impressive but economically questionable. Sol and Luna are OpenAI's answer to that problem.

The underlying philosophy is straightforward: make advanced intelligence cheaper and faster so developers can use it more often.

For developers and businesses, the headline capability improvements are only half the story. The other half is cost. OpenAI says GPT-6 Sol and GPT-6 Luna are priced at roughly half the cost of their GPT-5.6 counterparts for standard API usage. GPT-6 Sol is priced at $2 per million input tokens and $10 per million output tokens. GPT-6 Luna goes substantially lower, at $0.10 per million input tokens and $0.50 per million output tokens. There is also a significant reduction for cached input, which matters particularly for applications that repeatedly send the same instructions, context or large system prompts.

This changes the economics of experimentation. When every additional model call is expensive, developers naturally design systems to minimize calls. When inference becomes cheaper, they can afford to let models perform more validation, attempt multiple approaches, route tasks between models, or run agents through longer workflows. In other words, cheaper intelligence doesn't merely reduce the bill. It can change what developers are willing to build.

GPT-6 Sol appears designed for the broad middle ground where most professional AI usage actually happens. It is intended for work that requires meaningful reasoning, coding, computer interaction and multi-step problem solving, without necessarily requiring the maximum capability of GPT-6 Astra. That makes Sol particularly interesting for software development and business automation.

Imagine an engineering organization using Astra for exceptionally difficult architecture or research problems, Sol for everyday coding agents and code review, and Luna for high-volume classification, extraction and routine transformations. The important innovation is not that one model does everything. It is that the models can work together as an economic system. A company can reserve expensive reasoning for the problems that genuinely need it while pushing routine work toward cheaper models. That is potentially far more consequential for enterprise AI than another benchmark record.

If Sol is the workhorse, Luna is the model you might expect to find quietly running behind the scenes of a very large number of applications. Luna is optimized for speed and cost efficiency. It is designed for workloads where enormous numbers of model calls matter more than having the deepest possible reasoning on every individual request. That opens the door to applications that previously looked too expensive to operate with larger models.

Customer-support classification, document processing, information extraction, lightweight agents, content transformation, routing, summarization and other repetitive tasks can generate enormous volumes of inference. At that scale, shaving a fraction of a cent from each operation can become meaningful. The irony of AI economics is that the most important model may not always be the one that produces the most impressive demo. Sometimes it is the one that can process ten million boring things before lunch without making the CFO nervous.

OpenAI is also emphasizing improvements in factuality, coding and computer use. One particularly notable claim is that GPT-6 Sol makes about half as many mistakes as GPT-5.6 Sol under OpenAI's evaluations. That does not mean the model is suddenly incapable of making mistakes. Nor should benchmark improvements be interpreted as a guarantee of correctness in every real-world application. But the direction is significant.

For production AI, reliability can be just as important as raw intelligence.

A model that occasionally produces a brilliant answer but frequently requires human correction can be less useful than a slightly less capable model that consistently gets routine work right. This is especially important for agents. As AI systems move from answering questions to actually taking actions, errors become more consequential. A bad paragraph is one thing. A bad database update, incorrect code change or mistaken workflow action is something else entirely. Improving factuality, coding reliability and instruction following therefore becomes part of the infrastructure of useful AI rather than merely another benchmark achievement.

Perhaps the biggest implication of Sol and Luna is what they mean for model selection. The future of AI applications is increasingly unlikely to be built around the assumption that every task should use the same model. Instead, applications can increasingly become intelligent routing systems. A difficult request can go to Astra. A complex but routine professional task can go to Sol. A high-volume, low-cost operation can go to Luna. That sounds simple, but it represents an important architectural shift.

AI applications are moving from "Which model should we use?" toward "Which model should handle this particular piece of work?" That distinction could become extremely important as organizations move from experimenting with AI to operating AI systems at scale.

The release of Sol and Luna also changes how we should think about the GPT-6 label. GPT-6 is no longer simply the name of one increasingly powerful model. It is becoming a family of models optimized for different combinations of capability, speed and cost. Astra sits at the high-capability end. Sol occupies the middle ground. Luna pushes toward efficiency and volume. That structure resembles what has happened throughout computing: specialized hardware and software eventually emerge because different workloads have different requirements.

Nobody uses a supercomputer to calculate the total of a shopping receipt. Likewise, not every AI task needs the most powerful reasoning model available. The economics eventually catch up with the technology.

For developers, the practical takeaway is that the cost of intelligence is falling while the range of possible architectures is expanding. Lower token prices make experimentation easier. Improved caching makes repeated context cheaper. Faster models make interactive applications more practical. Better reasoning and coding performance make AI agents more useful. Together, those changes can encourage developers to build systems that were previously too expensive or too slow.

It also makes optimization more nuanced. The goal is no longer simply to choose the cheapest model. It is to find the right balance between model capability, latency, reliability and cost. A cheap model that needs five attempts to complete a task may not actually be cheaper than a stronger model that succeeds on the first attempt. Conversely, using a premium model for a task that requires little reasoning is difficult to justify at scale.

The real opportunity lies in combining them intelligently.

For enterprises, Sol and Luna could make AI deployment less about isolated pilots and more about infrastructure. Organizations increasingly want AI embedded into workflows rather than sitting in a separate chat window. That means processing documents, assisting developers, analyzing tickets, monitoring operations, routing requests and interacting with enterprise systems continuously. Those workloads generate enormous numbers of model calls. Cost therefore becomes a product-design constraint.

A 50% reduction in model pricing can materially change the economics of a system that makes millions or billions of calls. Add caching, model routing and improved automation, and the business case for deploying AI throughout an organization can become considerably different.

The next phase of enterprise AI may therefore be less about asking whether AI can do something and more about calculating how cheaply, reliably and continuously it can do it.

The Bigger Picture lies in saying that GPT-6 Sol and Luna are not simply smaller siblings arriving after Astra. They represent a broader trend in AI: intelligence is becoming something that can be deployed at different price points and performance levels depending on the task. That is arguably more important than simply making the biggest model bigger.

The long-term competition in AI will not only be about who can build the most capable model. It will also be about who can make useful intelligence inexpensive enough to become ordinary infrastructure. That's where Sol and Luna become particularly interesting.

Astra may grab the headlines when a difficult problem demands maximum capability. Sol may become the model developers reach for when the work gets serious. And Luna may end up quietly powering the enormous volume of AI interactions that nobody notices because they simply become part of how software works.

The funny thing about technological revolutions is that the most transformative part is often the least glamorous. The future of AI might not arrive wearing a cape. It might arrive as a very large API bill that suddenly isn't quite so large.

#OpenAI #GPT6 #ArtificialIntelligence #GenerativeAI #AI #MachineLearning #LLM #AIEngineering #EnterpriseAI #Developers #Automation #Technology

The world of Jev

LLMs talk. Jev decides. We use LLMs for almost everything, even when the job is simply to make a decision.

• Is this request allowed? Yes / No

• Which route should we take? A / B / C

• What category does this belong to? Category X

• Should this transaction be approved? Yes / No

Do we really need a model that generates a paragraph of text just to answer that? 

TypeSafe AI's new model, Jev, takes a different approach. Instead of generating text and asking software to interpret it, it returns the decision itself, as a typed value from a schema you define: a boolean, a choice, a score. Single forward pass, no parsing, no invalid output.

The numbers make the case: ~70–500ms latency and roughly $0.0004 per decision, versus multi-second LLM round trips at $0.01–0.15. TypeSafe frames the gap as two to three orders of magnitude.

The way I see it:

• If a human is going to read the answer: an LLM makes sense.
• If software is going to consume the answer: you probably don't need a model generating text at all.

How many LLM calls in your applications are actually just classification or decision-making problems in disguise? Curious how others are approaching this in their AI architectures. Swipe for the full breakdown: primitives, cost, hallucination risk, and the detailed comparison.

#AI #AgenticAI #LLM #AIArchitecture #SoftwareArchitecture

Claude Opus 5.5: The Intern just got promoted

Anthropic has just released Claude Opus 5.5, and the interesting part of this release isn't simply that there's another number attached to the Claude family. The bigger story is what Anthropic is trying to optimize: not just raw model intelligence, but how effectively that intelligence can be put to work.

Released on September 22, 2026, Claude Opus 5.5 is the first model in Anthropic's new Claude 5.5 family. Anthropic says it delivers performance comparable to its higher-end Claude Fable 5.1 model across most work, while costing about 40% less to run than Opus 5. That combination matters. The AI industry has spent years chasing increasingly capable models, often with the implicit assumption that more intelligence inevitably means more compute, more latency and a larger bill. Opus 5.5 is a reflection of a slightly different direction: make the model capable enough to handle increasingly complex work but make it efficient enough that organizations can actually use it at scale.

In other words, the question is gradually changing from "How smart is the model?" to "How much useful work can the model get done before someone notices the invoice?"

The most significant theme around Opus 5.5 is its focus on long-running, agentic work. Anthropic positions the model as particularly strong at software engineering, multi-step agent workflows, professional knowledge work, financial analysis, computer use and complex research. The emphasis isn't merely on answering a question correctly. It is on understanding a larger objective, planning the work, interacting with tools, checking results and continuing until the task is actually finished. That distinction is makes all the difference.

A traditional chatbot interaction might look like this: ask a question, receive an answer, make a correction, ask another question and repeat until the result is usable. An agentic workflow looks more like assigning a project to a colleague.

"Investigate this problem, inspect the relevant files, figure out what's wrong, make the changes, run the tests and tell me what happened." That's a much more demanding job.

Anthropic says early testers have already used Opus 5.5 for substantial engineering projects, including one reported case involving a 680,000-line code migration completed in less than a day. Another example involved an engineering task spanning six repositories that reportedly ran unattended for more than 18 hours. These examples should obviously be viewed as vendor-reported experiences rather than universal guarantees. But they illustrate where the technology is heading: AI systems are increasingly being evaluated by the amount of end-to-end work they can complete rather than simply by how impressive an individual response looks.

Software development is arguably where the Opus 5.5 announcement becomes most tangible. Anthropic describes the model as its strongest Opus model for agentic coding, with capabilities spanning large codebases, debugging, refactoring, feature development and code review. It also emphasizes that the model can investigate root causes before making changes and verify its work along the way. That last part may prove more important than another incremental increase in benchmark scores.

In real software development, generating code is rarely the hardest part. Understanding an unfamiliar codebase, identifying the actual problem, avoiding unintended side effects and determining whether a change genuinely fixed the issue are often much harder. An AI system that writes 500 lines of code in ten seconds is interesting. An AI system that spends the next several hours figuring out which 20 lines actually need changing, checks the consequences and comes back with a tested solution is much more useful.

Anthropic also highlights improvements in token and tool-call efficiency. In one cited evaluation, Opus 5.5 completed terminal tasks with fewer steps than Opus 5. The company says this efficiency can translate directly into lower costs for agentic workloads. That is a significant development because agentic AI has an awkward economic problem: every additional tool call, retry, context window and generated token costs money. The smarter the model becomes, the more useful autonomous agents become. But the more autonomous they become, the more expensive inefficient behavior can become. Opus 5.5 appears designed to attack both sides of that equation.

The price story may be almost as important as the intelligence story. Anthropic lists Opus 5.5 at $4 per million input tokens and $20 per million output tokens, compared with higher pricing for Opus 5. Cache reads are priced at $0.20 per million tokens. Anthropic says typical workloads can cost about 40% less than Opus 5 while the model also generates output more than 30% faster. This is particularly relevant for enterprise applications. For a person chatting with an AI occasionally, a small difference in token cost may not matter much. For an enterprise agent operating continuously across thousands of tasks, however, token efficiency becomes a financial metric.

Imagine an organization deploying AI agents across software engineering, customer operations, research, analytics and internal automation. If every agent needs fewer model calls to accomplish the same task, the savings compound quickly. The competitive advantage of a model therefore isn't necessarily "it is 5% smarter." It may instead be "it gets the same job done with half the wandering around." And anyone who has watched an AI agent repeatedly call the same tool while confidently announcing that it is "making excellent progress" knows that this is not a trivial feature.

One of the more understated changes in Opus 5.5 is its communication style. Anthropic says the model has been improved to put important information up front, reduce unnecessary jargon and follow writing instructions more reliably. Early testers reportedly found its responses easier to follow during long sessions. This sounds cosmetic until you consider how AI is increasingly being used.

If a model is simply answering isolated questions, verbosity can be mildly annoying. If that model is acting as an engineering partner for six hours, generating project documentation, explaining decisions, reviewing code and coordinating multiple steps, poor communication becomes a productivity problem. A capable AI that produces technically correct but exhausting explanations can still create work for the human sitting in front of it. The goal with Opus 5.5 seems to be moving toward something closer to a competent colleague: explain what matters, show the important evidence, make the recommendation or change, and don't write a small novel about it unless somebody asks.

That may sound mundane, but in practical AI adoption, mundane improvements are often the ones people notice every day.

There is another dimension to Opus 5.5 that deserves attention: safety. Anthropic says Opus 5.5 performed strongly on its automated behavioral audit and has improved resistance to prompt injection compared with Opus 5. The company has also introduced safeguards around tool use, coding and autonomous workflows. This matters because giving an AI more autonomy changes the risk profile. A chatbot that produces an incorrect paragraph is one thing. An agent that can browse the web, modify files, execute commands, interact with software and continue working for hours is something else entirely.

The industry therefore has to solve two problems simultaneously: make agents capable enough to accomplish meaningful work and make them constrained enough that they don't creatively reinterpret their instructions along the way. Anthropic's release places considerable emphasis on this area, including stronger safeguards for cybersecurity and biology-related capabilities. The broader lesson is straightforward: as AI systems move from answering questions to taking actions, reliability and containment become just as important as intelligence.

The most interesting thing about Claude Opus 5.5 may ultimately not be any individual benchmark. It is the direction of travel. The AI industry is moving from models that primarily generate content toward systems that can execute workflows. The distinction is subtle but enormous. A model that writes a business plan is useful.A model that researches the market, analyzes the available information, creates the business plan, builds the financial model, produces the presentation and revises everything after receiving feedback starts to look less like a chatbot and more like an AI-powered work environment. Opus 5.5 is clearly aimed at that second category.

Anthropic is also positioning it as an enterprise-oriented model capable of producing documents, spreadsheets and presentations while handling complex professional workflows. It’s capabilities in vision and computer use further extend the idea beyond text and code. That creates an interesting future for knowledge work. The competitive advantage may increasingly belong not to organizations that simply "use AI," but to organizations that redesign their workflows around capable AI agents while keeping humans responsible for judgment, oversight and accountability.

Claude Opus 5.5 arrives at a point where model releases are becoming less about flashy demos and more about economics, reliability and sustained execution. A model that is slightly smarter but dramatically more expensive may not transform a business. A model that is slightly more capable, substantially cheaper, faster, better at following instructions and capable of operating for hours can. That is why Opus 5.5 is an interesting release.

It isn't just another model with a larger number after its name. It represents an attempt to make frontier-level AI more operational: something that can sit inside an organization's workflows and quietly get complicated work done. And perhaps that is the real milestone. The future of AI may not arrive as one spectacular conversation where a machine suddenly announces that it has become super-intelligent. It may arrive much more quietly. One morning, someone will realize that the AI didn't just answer the question. It finished the project.

And, rather inconveniently for everyone's calendar, it finished it before lunch.

#Claude #ClaudeOpus #Opus55 #Anthropic #GenerativeAI #ArtificialIntelligence #AI #AIAgents #AgenticAI #SoftwareEngineering #EnterpriseAI #FutureOfWork

How does an AI Agent respond?

Ever wondered what actually happens inside an AI agent before it responds?

Most people assume AI just generates an answer instantly. But true agentic AI behaves more like an autonomous analyst: it plans, uses tools, checks its own work, and corrects errors before delivering a result.

Here's the 9-stage loop, broken down:

1. Understand: Clarifies intent, respects constraints, and factors in context.
2. Plan: Breaks the goal into steps, picks the right tools, defines what success looks like.
3. Retrieve: Pulls from memory/state and uses RAG to fetch external or private data.
4. Reason: The LLM processes context and decides: answer directly, or take action?
5. Act: Executes using search, APIs, code, databases, or MCP tools.
6. Observe: Checks the result: did it work? Were there errors? Any new info?
7. Loop: Plan ↔ Reason ↔ Act ↔ Observe repeats until the result is valid and complete. This loop is what makes it an agent.
8. Verify: Runs evals, applies guardrails, checks confidence before anything reaches the user.
9. Final Answer/Action: Responds, writes output, or triggers a workflow (e.g. sending an email, updating a CRM).

The real power of agentic AI isn't generation but it's execution.

#AIAgents #ArtificialIntelligence #SoftwareEngineering #Automation #TechTrends

Omega-3 - All you need to know

Flax seeds alone aren’t enough for Omega-3. This is something I see many vegetarians misunderstand.

Omega-3 is not just one fatty acid. It includes three important forms

1. ALA ( Alpha-Linolenic Acid)

2. EPA ( Eicosapentaenoic Acid) and

3. DHA ( Docosahexaenoic Acid).

Flax seeds, chia seeds, walnuts and hemp seeds are excellent sources of ALA. But the body’s conversion of ALA into EPA and DHA is limited.

So if you’re vegetarian, don’t stop at flax seeds. Algae-based omega-3 can be a useful source of DHA and, in some formulations, EPA. EPA supports cardiovascular health, while DHA is particularly important for the brain and eyes.

Don’t just ask, “Am I getting omega-3?” Ask, “Which forms of omega-3 am I getting?”