srihari kodam

Simple person with love of reading books, data sciences and programming in python and R.

[Rahul @sairahul1]

This is the best site on the internet to learn how LLMs actually work.

Free. Completely.

https://t.co/NBlP0Q9YV3

Bookmark this site.

Then read this ↓

[Ajay @ajay4ai]

A senior Anthropic engineer just dropped a 12-page PDF that quietly exposes why most multi-agent systems are fundamentally broken.

Your agents forget everything once their context window dies.

Graph Engineering fixes that.

Instead of resetting their memory every run, you give your agents a persistent knowledge graph they can write to, query, verify, and build on.

The loop is brutally simple:

Extract → Resolve → Assemble → Query → Repeat

And the architecture is even crazier:

• Extract: Haiku pulls entities + S-P-O triples from every document. One call per doc. The Pydantic schema is the only training data.

• Resolve: Sonnet figures out that “Edwin Aldrin” = “Buzz Aldrin” even with zero string overlap, using descriptions as context.

• Assemble: Canonical nodes. Typed edges. Provenance on every triple. Everything becomes one connected graph.

• Query: Serialize only the relevant subgraph → Sonnet reasons over it → every answer can point back to a specific edge.

Now plug that into a multi-agent system:

Workers write to the graph.

Evaluators fact-check against it.

Agents share memory.

Loops can keep running overnight.

No more pretending a context window is memory.

This 12-page PDF completely changed how I’m thinking about multi-agent systems.

Read it before everyone starts calling this “obvious.”

Then explore the article below.

[Matt Dancho (Business Science) @mdancho84]

🚨BREAKING: MIT researchers discover how to enable LLMs to do real logical reasoning.

This is what you need to know:

(thread)

[chuplung @choopyplug1]

https://t.co/LSAMpgaool

[srihari kodam @Sriharimba]

@abhijeet_dipke @drummatick But RTI act is there for this information, probably you can raise requests under RTI Act.

[Dan Kornas @DanKornas]

Hugging Face Transformers End to End Course

What you will learn:
- Understand transformer and LLM concepts without treating them as black boxes
- Understand how models learn, optimize, and improve from data
- Work with sequence, text, and language-modeling problems
- Build a practical understanding of this part of LLMs and generative AI
- Understand sequence models like RNNs and LSTMs for NLP applications

Link is in the reply 👇

♻️ Share this with your network if you found it useful or insightful.

[Akshay 🚀 @akshay_pachaar]

Karpathy's agentic engineering lifecycle, clearly explained:

(using open-source tooling built by Google)

The tooling to build agents is quite mature, so most of the work in shipping an agent isn't writing the agent anymore.

It's everything after, including scaffolding it, deploying it to a runtime, locking down its identity and network, evaluating it, and publishing it somewhere people can use.

Each of those has traditionally lived in its own console, its own config, its own separate tool.

Google's Agents CLI + skills implements procedures to condense the entire lifecycle into the coding agent itself, by prompting in plain English.

A setup command injects the lifecycle skills, so a single coding agent can carry an idea from an empty folder to a governed, published enterprise asset.

I mapped the full lifecycle in the diagram below. Here's what each stage does.

> Setup installs the skills into any coding agent (Claude Code, Cursor, Codex, Antigravity) from one command.

> Build scaffolds the agent and its deterministic tools from a prompt, then you run it locally in the playground.

> Deploy pushes it onto Agent Runtime with Sessions and Memory Bank, so it holds state across runs.

> Govern is the security stage, and Agents CLI drives all of it from prompts. It provisions a dedicated least-privilege identity, screens untrusted text for prompt injection through Model Armor, and confines the agent to an egress allow-list of hosts you approve.

> Evaluate checks grounding and hallucination, and then optimizes the prompt while proving no regression.

> Publish registers the agent into Gemini Enterprise for the whole org to use.

Every stage requires just natural-language prompts.

Agents CLI GitHub repo → https://t.co/yftnQghadn

(don't forget to star it ⭐)

To dive deeper, I wrote the full hands-on build, from install to enterprise registration, and worked with the Google Cloud team to put this together.

Read it below.

[Tech with Mak @techNmak]

There are 2 career paths in AI right now:

The API Caller:
Knows how to build with LLMs.

The Architect:
Knows how LLM systems are built.

If you want to move toward the second, Stanford has one of the best free LLM engineering playlists on YouTube:

CS336: Language Modeling from Scratch.

The 2026 course has 19 lectures covering almost the entire LLM stack -
➡️ Build the model: Tokenization, Transformers, architectures, MoE
➡️ Understand the hardware: FLOPs, memory, GPUs, TPUs
➡️ Make it fast: Triton, GPU kernels, parallelism, distributed training
➡️ Train it: Scaling laws, data collection, filtering, deduplication
➡️ Run it: Inference, evaluation
➡️ Post-train it: SFT, RLHF, RLVR

Plus multimodality.

And you don’t only watch lectures.
> You implement the tokenizer, Transformer and optimizer.
> You write FlashAttention2 in Triton.
> You build memory-efficient distributed training.
> You turn raw Common Crawl dumps into pretraining data.
> You fit a scaling law.
> You use SFT + reinforcement learning to train a language model for mathematical reasoning.

Stanford says students write at least an order of magnitude more code than in most other AI classes.
Stanford CS336. Spring 2026. 19 lectures. Free on YouTube.

Choose your path.

(Playlist in the comments.)

♻️ Repost to save someone $$$ and a lot of confusion.

[Hanako @hanakoxbt]

ANTHROPIC LEAKED A 4-AGENT SETUP THAT CUTS A CODEBASE AUDIT FROM 3 DAYS TO 20 MINUTES

you point it at a repo and walk away - it comes back with what breaks, ranked, patches already tested.

repo → map → 4 auditors → rank → fix → verify → report → back into the map

the map cuts the repo by blast radius, not by folder - skip it and four agents audit the same three files and miss the one that ships broken.

4 auditors run in parallel with separate contexts - deps, secrets, dead code, hot paths, and none of them sees another's findings.

rank is code, not an agent - sort by what breaks production, drop the duplicates, zero tokens.

the fixer only opens patches for the top slice - a hundred findings nobody acts on is a report, not an audit.

verify runs the suite on every patch and red goes back to the fixer - that patch only, never the whole batch.

the back edge into the map is the whole trick - accepted findings become rules, so next week starts where this one ended.

one human step in all of it: which fixes ship - 20 minutes instead of 3 days.

save this and read the full graph engineering course below ↓

[Akshay 🚀 @akshay_pachaar]

DeepSeek has open-sourced DeepSeek Harness.

(crossed 35k stars in a few hours)

it is built around one core idea: everything is a plugin

let me explain what that means:

the model adapter, the tool registry, the session log, and the agent loop itself are all plugins in DeepSeek Harness (dsh). every one of them can be swapped for your own.

that matters because changing how an agent assembles context usually means editing the framework's own source, or forking it and paying for that fork on every upgrade.

the mechanics that make it work:

→ a plugin claims a stable key like ctx .tools or ctx .llm, and other plugins find it by that key instead of importing a concrete implementation.

→ dependencies are declared rather than hand-sequenced, so load order falls out of what each plugin requires.

→ registrations are reversible, so unloading a plugin unwinds everything it registered.

→ one event, agent/pre-step, decides what the model sees. listeners can rewrite the claimed messages or reject them, which is where nearly all custom context engineering would land.

→ the session log is append-only and covers system prompts, reasoning, tool calls, subagent scheduling, and every context injection.

that last one is what i would actually reach for.

logging tool calls is standard, and when an agent misbehaves you are still guessing at what was in the window. here, model-visible means logged, asserted at runtime, so a new model-visible input requires a new session event.

deepseek was the last major lab shipping coding-grade models without a first-party harness to train against, and it now ships one that can delegate subagent work to Claude Code and Codex.

link to GitHub repo: https://t.co/Q7jrt6qxvk

if you want the full anatomy of what a harness actually contains, the article is quoted below.

[Anatoli Kopadze @AnatoliKopadze]

This is still the most useful 2 hours on AI I've ever watched, Andrej Karpathy breaking down how he actually uses it daily:

18:03 - Which model to actually use
22:54 - When thinking models are worth it
42:04 - One prompt to a full research report
59:00 - Make the model run code for you
1:53:29 - Make it remember you across chats

Most people use 10% of what these models can do, this is the other 90%.

I took everything he covers and turned it into a guide of Claude features almost nobody knows about.

Watch the video first, then go to the article below with ready-to-copy prompts.

[Mr. Buzzoni @polydao]

CLAUDE + OBSIDIAN + LOOP ENGINEERING = AN AGENT THAT LIVES IN YOUR NOTES

Karpathy's second brain runs on something close to this. two years of growth. he barely typed any of it

four steps, on repeat:
1. read - Claude Opus 5 opens the vault, not a chat window
2. write - notes and links change inside a branch
3. check - a critic reads the diff, checks every link
4. keep - the good change sticks. nothing gets touched

cost: 2-4x a single prompt. worth it past a 5% gain. zero notes overwritten. the vault only grows

the whole system runs on six plain files: CLAUDE.md, skills, subagents, hooks, MCP, plugins. no black box

three ways in: a desktop connector for three clicks, Claude Code for full control, or the Obsidian plugin if you never want to leave the app

append, don't overwrite. measure the win before adding a step. never let it rewrite the whole vault in one turn

a loop that never deletes a note is compound interest for your own thinking

[MARLON @ItsyourSKi07]

HOW TO USE CLAUDE: THE ONE CHEAT SHEET TO USE CLAUDE THE RIGHT WAY

[Codez @0xCodez]

Anthropic engineer:

"At Anthropic, 85% of our engineers building agentic Loops and Graphs powered by MCP

Loops + Graphs + MCP - that's how the self-learning agentic system looks like"

in a 30-minute workshop, the Anthropic engineer who created MCP reveals how to build a self-learning agentic system

Worth more than a $500 agentic course on the internet

Watch the masterclass, then read how to build self-learning agents with MCP in the article below

[Shubham Saboo @Saboo_Shubham_]

Build context graph for AI Agents. 100% Opensource.

[Dhanian 🗯️ @e_opore]

📂 API Design Roadmap
┃
┣ 📂 Foundations
┃ ┣ 📂 What is an API?
┃ ┣ 📂 HTTP & HTTPS Fundamentals
┃ ┣ 📂 Request & Response Lifecycle
┃ ┣ 📂 JSON & Data Formats
┃ ┗ 📂 API Design Principles
┃
┣ 📂 REST API Design
┃ ┣ 📂 REST Architecture
┃ ┣ 📂 Resources & Endpoints
┃ ┣ 📂 HTTP Methods (GET, POST, PUT, DELETE, PATCH)
┃ ┣ 📂 Status Codes
┃ ┗ 📂 REST Best Practices
┃
┣ 📂 API Documentation
┃ ┣ 📂 OpenAPI Specification
┃ ┣ 📂 Swagger UI
┃ ┣ 📂 API Reference Documentation
┃ ┣ 📂 Examples & SDKs
┃ ┗ 📂 Versioned Documentation
┃
┣ 📂 Authentication & Authorization
┃ ┣ 📂 API Keys
┃ ┣ 📂 JWT Authentication
┃ ┣ 📂 OAuth 2.0 & OpenID Connect
┃ ┣ 📂 Role-Based Access Control (RBAC)
┃ ┗ 📂 Token Management
┃
┣ 📂 API Security
┃ ┣ 📂 HTTPS & TLS
┃ ┣ 📂 CORS Configuration
┃ ┣ 📂 CSRF & XSS Protection
┃ ┣ 📂 Rate Limiting & Throttling
┃ ┗ 📂 Input Validation & Sanitization
┃
┣ 📂 Advanced API Architectures
┃ ┣ 📂 GraphQL
┃ ┣ 📂 gRPC
┃ ┣ 📂 WebSockets
┃ ┣ 📂 Server-Sent Events (SSE)
┃ ┗ 📂 Event-Driven APIs
┃
┣ 📂 API Performance
┃ ┣ 📂 Pagination
┃ ┣ 📂 Filtering & Sorting
┃ ┣ 📂 Caching Strategies
┃ ┣ 📂 Compression
┃ ┗ 📂 Performance Optimization
┃
┣ 📂 API Reliability
┃ ┣ 📂 Error Handling
┃ ┣ 📂 Retry Strategies
┃ ┣ 📂 Idempotency
┃ ┣ 📂 Circuit Breaker Pattern
┃ ┗ 📂 Health Checks
┃
┣ 📂 API Testing
┃ ┣ 📂 Unit Testing
┃ ┣ 📂 Integration Testing
┃ ┣ 📂 Postman & Insomnia
┃ ┣ 📂 Load Testing
┃ ┗ 📂 Contract Testing
┃
┣ 📂 API Deployment
┃ ┣ 📂 API Gateways
┃ ┣ 📂 Reverse Proxies
┃ ┣ 📂 Docker & Containers
┃ ┣ 📂 CI/CD Pipelines
┃ ┗ 📂 Cloud Deployment
┃
┣ 📂 Monitoring & Observability
┃ ┣ 📂 Logging
┃ ┣ 📂 Metrics Collection
┃ ┣ 📂 Distributed Tracing
┃ ┣ 📂 Prometheus & Grafana
┃ ┗ 📂 API Analytics
┃
┣ 📂 AI-Powered APIs
┃ ┣ 📂 OpenAI API Integration
┃ ┣ 📂 Function Calling
┃ ┣ 📂 Streaming Responses
┃ ┣ 📂 AI Agent APIs
┃ ┗ 📂 Cost & Token Optimization
┃
┣ 📂 Real-World Projects
┃ ┣ 📂 Authentication API
┃ ┣ 📂 E-commerce REST API
┃ ┣ 📂 Payment Gateway API
┃ ┣ 📂 AI Chat API
┃ ┗ 📂 Microservices API Platform
┃
┣ 📂 Practice & Growth
┃ ┣ 📂 Build Public APIs
┃ ┣ 📂 Contribute to API Projects
┃ ┣ 📂 Write API Documentation
┃ ┣ 📂 API Design Reviews
┃ ┗ 📂 Interview Preparation
┃
┗ 📂 Career & Monetization
┣ 📂 Backend Engineer Roles
┣ 📂 API Platform Engineer
┣ 📂 SaaS Development
┣ 📂 API Consulting & Freelancing
┗ 📂 Continuous Learning

Follow this consistently for 2–4 months and you'll be able to design, build, secure, and scale production-ready APIs with confidence.

Grab the API Design Ebook:
https://t.co/t2KOeauy6O

[Akshay 🚀 @akshay_pachaar]

LLM engineer's handbook

(30 minutes a day, 10 weeks, 50 lessons)

a roadmap for llm inference serving where everything points at one service instead of scattering across demos. you get the mental model first, then serve a model, instrument it, load test it past 1000 concurrent requests, and tune it. you finish with a stack you configured yourself and a benchmark worth publishing.

here is what it covers:

→ the roofline model, and why decode waits on memory while prefill waits on compute

→ vLLM internals, PagedAttention and the scheduler, read from the code

→ Prometheus and Grafana for TTFT, inter-token latency, and queue depth

→ SGLang and RadixAttention prefix reuse, benchmarked against vLLM

→ load testing past 1000 concurrent requests

→ quantization across FP16, FP8, and INT4, on quality as well as speed

→ speculative decoding and KV eviction, including where the gains disappear

→ disaggregated prefill and decode, deployed on Kubernetes

→ a cost, latency, and quality router with per-request token budgeting

→ publishing a reproducible benchmark

the roadmap on GitHub: https://t.co/pOqkWvDJ2d

(don't forget to star 🌟)

i am also writing an article for each major topic. the first one is out, on how a GPU actually works.

the article is quoted below.

[Harrison Chase @hwchase17]

It’s beautiful

[Hanako @hanakoxbt]

ANTHROPIC LEAKED A 6-AGENT SETUP THAT TURNS ONE PROMPT INTO A FINISHED PR

your name shows up in this process exactly once - at the very end, for 5 minutes.

spec → planner → 3 builders → critic → scribe → PR → back into the spec

the planner runs once and the whole line inherits its decisions - a bad plan executed by five perfect agents is still a bad result.

3 lanes build in parallel - and they only work because the planner cut the steps so none of them reads another's output.

tests loop until green and red goes back to the coder - the critic never sees a broken build.

the critic rejects to the plan, not the code - tests ask does it run, the critic asks should it exist.

the scribe writes the PR from the trace, not from memory - cut this seat and you get 8 PRs nobody can tell apart.

the back edge into the spec is the whole trick - today's failures become tomorrow's constraints without you typing them.

one human step in the whole thing: approve or send back - 5 minutes instead of 5 hours.

save this and read the full graph engineering course below ↓

[Akshay 🚀 @akshay_pachaar]

Stanford researchers did it again.

They just built the agent-native version of Git.

When an agent works on a longer task, the run builds up a lot of state.

This includes files edited/created, a dev server, a database, installed packages, KV cache, etc.

Say the agent is at step 10 and makes a mistake, maybe it misreads a traceback and rewrites a file that was actually fine.

The tests start failing, and the run goes off track, although everything through step eight was correct.

By default, the agent just tries to fix it, which creates more edits and tool calls. This burns more tokens and grows the context.

The other options are a person stepping in to redirect it or restarting the whole run from step one.

That's wasteful, because it pays for every model/tool call again and re-prefills the context. Moreover, since an agent's run is non-deterministic, it doesn't reproduce the same early steps anyway.

The reason it's hard to just jump back exactly to a previous correct step and resume from there is that the trajectory is only a message log.

It records what the agent said and which tools it called, but not the live state underneath.

That state includes things like memory, open file handles, child processes, installed packages, /tmp, and KV cache. None of that is in the log.

Git can version the files, but it doesn't snapshot the running process or the KV cache. Checking out step eight moves the files back, but the process is still sitting in step-ten memory with a cold cache.

Shepherd is a runtime layer by Stanford that records the run as a trace of typed events rather than a flat log.

Each agent-environment interaction becomes a commit, similar to Git, but it tracks the live run.

Its commit includes the agent process and the filesystem together, copy-on-write, so a branch carries the actual state and not just the files.

Going back to a previous step is then a single call that forks from that commit and continues from the exact state.

The copy-on-write fork is roughly five times faster than docker commit, and because the prompt prefix through step eight is unchanged, the KV cache is reused over 95% on replay, so early steps aren't reprocessed again.

Once the run can be forked, a meta-agent can sit on top and operate it. It watches the trace and reverts as soon as it looks wrong, before the bad write is committed.

In practice, it's just Python calling fork, replay, and revert on the trace, rather than a separate control plane wired into the harness.

Not everything is reversible though.

Files and sandbox changes undo themselves, but a database write has no automatic undo, so it needs a matching undo step set up in advance.

Something external, like a sent email or a real charge, can't be undone, so the supervisor's job there is to catch it before it fires.

They tested this on a few public benchmarks. On CooperBench, where two agents work on the same codebase, adding a live supervisor took the pair-coding pass rate from 28.8% to 54.7%.

It's still early and labeled alpha. The benefit mostly shows up when a run gets branched a lot over a heavy sandbox state, which is exactly where restarting wastes the most tokens and time.

If Git was made to make file changes reversible, Shepherd is trying to do the same thing for a live agent run.

Shepherd Repo: https://t.co/uUIS57te6g

(don't forget to star it ⭐ )

That said, Shepherd reverts a bad step inside a run. The harness around it, the prompts, tools, and checks the supervisor relies on, still drifts across runs as models and dependencies change.

I wrote about making that harness repair itself, where a failing trace gets diagnosed, the fix is verified against the exact input that failed, and the failure is locked as a regression test so it can't recur.

The article is quoted below.