Holy f*ck, Google just dropped a free 2-hour course on Harness, Loop and Graph engineering
From one prompt to 100+ agents that test, judge and fix their own work:
0% → 0:29 - Harness engineering from scratch
15% → 11:08 - Build your first agent the right way
30% → 28:03 - Evals: an agent that grades its own work
65% → 1:00:13 - Loop engineering: send bad work back until it passes
100% → 1:18:45 - A self-improving graph that gets better while you sleep
Prompts → Agents → Harness → Loops → Self-Improving Graphs
Most people still trust an agent just because its answer "looks right"
Worth more than any $2,500 agentic engineering course
Save it and watch it tonight
Then read how to build the full harness in the guide below ↓
Google just dropped a 9-page PDF on building agents that run for days - 6 layers to an agent that waits in line, survives a crash and never charges you twice:
the formula: Long-Running Agent = Trigger + Runner + State + Resumable Workflow + Human Gate + Guards
here's how to build your own in 6 layers:
layer 1 → trigger - the model can't set a timer. a scheduler hits a /wake endpoint and the agent runs again
layer 2 → runner - adk web is a dev tool. your server owns the runner, the sessions and the storage
layer 3 → state - session in a real database, preferences under user:, facts in memory. a restart loses nothing
layer 4 → resumable workflow - kill the server mid-queue. it resumes at the same node. finished steps never run twice
layer 5 → human gate - the agent asks for a budget and waits for a yes. the pause survives restarts too
layer 6 → guards - re-check the seat before buying, one idempotency key per order. a retry never charges twice
most agents die when the request ends. this is how you build one that doesn't.
the workflow in layer 4 is a graph. how to design the whole agent system that way is in my article below
Prasad Kodukulla retweeted
Anthropic engineer:
"You're not supposed to prompt Opus 5.5
You're supposed to build a system that prompts itself. At Anthropic, 90% of our engineers have already built such systems"
In 30 minutes she shows exactly how Anthropic builds agents that remember, fix their own errors and get sharper with every run.
This beats any $1000-$2000 course on agents I've come across.
Watch it, then read the article below ↓
Prasad Kodukulla retweeted
holy f*ck, Karpathy put an entire AI degree on GitHub for free
7 repos, 306,741 stars, and in the right order they take you from backprop to agents that run research overnight
each repo is the next layer of the one before
1. micrograd -> how a neural net actually learns
backprop in about 100 lines of Python
↳ github.com/karpathy/microgra…
2. nn-zero-to-hero -> the video course
his lecture notebooks, from one neuron to GPT
↳ github.com/karpathy/nn-zero-…
3. minbpe -> how text turns into tokens
the tokenizer every LLM starts with, in clean minimal code
↳ github.com/karpathy/minbpe
4. nanoGPT -> your own GPT
the simplest repo to train and fine-tune one
↳ github.com/karpathy/nanoGPT
5. llm.c -> the same training with nothing hidden
raw C and CUDA, no PyTorch underneath
↳ github.com/karpathy/llm.c
6. nanochat -> a full chat model end to end
GPT-2 level training cost ~$43,000 in 2019
here it's about $48
↳ github.com/karpathy/nanochat
7. autoresearch -> agents that do the research
an agent edits the training code, trains for 5 minutes, keeps what improved and repeats all night
↳ github.com/karpathy/autorese…
train one GPT from scratch and you become the person who gets handed the AI project, along with the raise that comes with it
the classroom half of the same degree, what Stanford actually teaches about AI, is below ↓
Prasad Kodukulla retweeted
Google just open-sourced Harness².
(turn any harness into a self-improving system)
a harness is everything wrapped around the model, like the system prompt, tools, memory, skills, and subagents. today a person designs it once, and the agent runs every new task with that same fixed setup.
Harness² lets the agent refine that setup for each new task on its own, with the model weights left untouched.
on every task, the agent proposes edits to its harness, runs a few candidate versions, and composes a better harness by comparing how those runs behaved.
because it learns from the differences between runs, it needs no correct answer or grader for the task.
that covers a single task. Harness² also carries what it learns from one task into the next.
after each task, it saves the harness it settled on along with the lessons that held up across the runs. the next time it refines a harness, it starts from those notes instead of from scratch.
this means every finished task makes the next round of edits more informed.
Google tested this with Gemini 3.5 Flash and GLM-5 on legal, office, and professional work benchmarks. one round of edits was enough to beat their original harnesses, and giving the agent more rounds pushed scores higher.
those extra rounds can go wide or deep. the agent either tries several candidate harnesses at once or keeps refining a single one step by step, using OpenCode or Codex to carry out the work.
you can find the Harness² repo here: github.com/google-research/h…
I wrote about a similar idea for agents already running in production, where the harness should repair itself after a failure instead of waiting for someone to debug the trace by hand.
that piece walks through how @Cometml's Opik (open-source) closes this loop, going from a failing trace to a proposed fix to a regression test that stops the same failure from coming back. it's quoted below.
THIS IS A ACTUAL F*CKING GOLDMINE
Anthropic just shared one of the best tricks for Claude Code
The idea: run Sonnet, Haiku 5.5 and Opus 5.5 at once, each doing only what it's best at
Better results and way fewer tokens: every task lands on the right model
You just start Claude Code like this:
CLAUDE_CODE_SUBAGENT_MODEL=haiku claude --model sonnet
here's how it splits:
→ Sonnet 5.5 runs the main session, writes the code, and applies fixes
→ Haiku 5.5 swarms the repo in parallel: search, grep, docs, and test audits at 340 tok/s
→ Opus 5.5 stays on call as architect for the big decisions and signs off on diffs
→ you stop burning Opus context on routine tasks and stop flooding main session with raw logs
Opus only steps in at three moments:
→ before a plan locks
→ when the same error hits twice
→ before calling it done (signing off on git diff)
Sonnet builds, Haiku swarms, Opus reviews
JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split
the full tree
> Sonnet 5.5 runs the main session and coordinates code implementation
> search maps the repo on Haiku 5.5 (read-only, 340 tok/s)
> grep finds call sites on Haiku 5.5 (0.05x cost, isolated context)
> audit scans diffs in a temporary worktree (isolation: worktree)
> Opus 5.5 on call as architect, reviews synthesized diff before sign-off
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Reconfigure my Claude Code setup around this tree:
1. Run the main session on Sonnet 5.5 with Opus 5.5 as architect
2. Create three custom Haiku 5.5 subagents in .claude/agents/: search (maps repo), grep (finds call sites), and audit (runs isolated diff checks in a worktree)
3. Set isolation: worktree on audit so modifications never touch my working branch
4. Add one rule to CLAUDE.md: delegate all repository searches and test runs to Haiku 5.5 subagents to keep main context under 10k tokens
5. Route fast deterministic forks (tool choice, path selection, retries) through JEV
Show me every change as a diff first. No edits until I say go"
↳ code.claude.com/docs/en/sub-…
save it, it'll come in handy
Prasad Kodukulla retweeted
I built a data analyst agent with Jev as the review layer!
Qwen handles the main agent work, Jev acts as the review layer, and Vercel eve runs the agent loop, tool execution, and human approval flow.
The agent takes a plain-English question about the data, inspects the database schema, writes the SQL, runs the query, and explains the result.
The interesting part is what happens around that main loop.
Qwen is responsible for generating the SQL and the final answer, while Jev reviews the parts where semantic judgment is actually useful. Anything that can be checked reliably with code stays deterministic.
Jev reviews the agent at three points:
- Before the agent starts, it checks whether the user's question is clear enough to answer from the available data.
- After Qwen generates the SQL, it checks whether the query actually represents what the user asked.
- After the query runs, it checks whether the final explanation is grounded in the returned rows.
For example, we tested it with:
“Who is our best customer?”
The question sounds simple, but “best” could mean highest revenue, most purchases, highest average order value, or something else.
Instead of letting Qwen silently choose a metric, Jev flagged the question as ambiguous and asked for clarification.
The same separation applies to SQL execution.
Qwen can propose a query, but it cannot decide whether that query is safe to run. The tool accepts only a single read-only `SELECT`, SQLite runs in read-only mode, results are capped at 200 rows, and queries without a `WHERE` clause can require human approval before execution.
Those checks do not need another model call.
But a query can be completely safe and still answer the wrong question.
A deterministic rule can verify that the SQL is read-only. It cannot reliably judge whether a query for “revenue last month” accidentally calculates revenue across all time.
That is where Jev comes in.
It reviews the proposed SQL against the original question and schema before execution. After the rows come back and Qwen writes the explanation, Jev reviews that answer again to check whether the claims are actually supported by the returned data.
The project uses a local SQLite sales database, Qwen through the Vercel AI Gateway, Gradio for the interface, and only two database tools: "inspect_schema" and "run_sql".
No single model is responsible for everything. Qwen generates, Jev reviews, deterministic code controls execution, and Vercel eve manages the agent loop and approval flow.
GitHub Repo: github.com/Sumanth077/Hands-…
100% open source.
Prasad Kodukulla retweeted
Train your own Decision model like Jev locally!
Unsloth now lets you fine-tune models like Qwen, Llama, and Gemma into decision models that make bounded decisions instead of generating text.
The model reads the input together with the questions and options you define, then a small decision head scores those options and returns the selected answer with probabilities.
So instead of using a generative model for every routing, classification, policy, or evaluation decision, you can train a much smaller model specifically for the decisions your system needs to make.
Training is done with LoRA, and the dataset format is simple: input state, the questions to decide, and the gold answers.
Unsloth also calibrates the model on held-out data, so the returned probabilities are meant to better reflect how often the model is actually correct.
The reported results are pretty interesting.
Qwen3.5-0.8B reached 78% holdout accuracy using around 4GB VRAM, while Llama 3.2 3B reached 79% at around 4.1GB VRAM.
Qwen3.5-0.8B also improved from 36% to 73% on typed decisions after fine-tuning.
Key capabilities:
- Fine-tune Qwen, Llama, Gemma, or other supported LLMs into decision models
- Train locally with 4-bit LoRA and relatively low VRAM
- Handle choice, yes/no, and scored decisions in the same model
- Return probabilities for each decision instead of generating free-form text
- Calibrate the trained model on held-out data before serving it
The part I like here is that you no longer need a purpose-built decision model to experiment with this architecture.
You can take an existing open model, fine-tune it for your own decision space, and run the whole thing locally.
I’ve shared the full Unsloth guide in the comments!
I also built a data analyst agent with Jev as the review layer, and I’ve shared the full breakdown in the article below.
Prasad Kodukulla retweeted
This workflow will save you thousands with Claude.
Run Opus 5.5, Sonnet 5.5, Haiku 5.5, and Fable 5.1 together, and stop spending Opus tokens on work that doesn't need Opus.
The entire idea in one line:
Opus plans, Sonnet edits, Haiku reads, Fable reviews at decision points.
Roles, broken down:
- Opus 5.5, high effort, owns the plan and reviews the final code
- Sonnet 5.5, medium effort, is the worker: edits files, runs tests
- Haiku 5.5, low effort, splits into explorer (searches and reads the codebase) and researcher (pulls docs). it's the first Haiku with an effort setting
- Fable 5.1, set with /advisor fable. Opus calls it at decision points, and it gets the full transcript each time
Three moments Opus tends to call it:
→ before committing to a plan: is this the right approach?
→ the same error shows up again: is this going nowhere?
→ before marking the task done: did something get skipped?
Why Haiku only reads: Anthropic's launch post says Sonnet 5.5 and Opus 5.5 are still the better choice for complex agentic coding (Terminal-Bench 4.0: 39.2% for Haiku 5.5, 70.6% for Sonnet 5.5) and that Haiku 5.5 fits narrowly scoped subagent work. so it gets the lookups, not the edits.
Anyone still running one model for everything is paying $4 per million input tokens to check whether a file exists. Haiku 5.5 does it for $0.10.
Drop this into Claude Code 👇
"Rebuild my Claude Code setup around this structure:
Confirm Claude Code is v2.1.293 or later, so the haiku alias resolves to Haiku 5.5. If it isn't, stop and tell me to run claude update.
Look through ~/.claude/agents and .claude/agents for subagents already covering explorer, worker, and researcher. Only create new ones for roles that are missing. Set model: haiku, effort: low on explorer and researcher, with no Edit or Write tools. Set model: sonnet, effort: medium on worker. If an existing subagent is locked to a different model, leave it as is and just list it.
Name the explorer subagent Explore so it overrides the built-in one, which otherwise runs on my main model.
In ~/.claude/settings.json, set advisorModel to fable, and set effortLevel to high for claude-opus-5-5 under modelSettings. A top-level effortLevel in user settings doesn't apply to Opus 5.5.
Check for anything disabling the advisor: CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, or anything blocking feature-flag fetches. Also check CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort settings, and CLAUDE_CODE_SUBAGENT_MODEL_FORCE, which makes Claude Code ignore subagent model fields. Report what you find. Don't change any of it yet.
Add one line to ~/.claude/CLAUDE.md: consult the advisor before a big plan, when the same error shows up twice, and before marking a long task done.
Show every change as a diff first. Wait for my go-ahead before touching anything."
Prasad Kodukulla retweeted
RAG vs. Jev + RAG, clearly explained!
In a standard RAG setup, documents are split into chunks, converted into embeddings, and stored in a vector DB.
When a query arrives, the system embeds it and retrieves the top-k chunks with the closest vectors.
Many production setups add a reranker after retrieval.
The reranker compares the query with each retrieved passage, improves their ordering, and keeps the highest-scoring results.
Those passages are then placed in the context window, and the LLM generates an answer from them.
The problem is that ranking and answerability are different questions.
A passage can be more relevant than the other candidates while still containing weak, incomplete, or merely adjacent evidence.
The LLM receives it anyway and may produce a plausible answer from context that never supported one.
Jev + RAG keeps the retrieval stage as is but changes what happens before generation.
Instead of using a conventional reranker at this stage, Jev can judge every retrieved candidate against a typed question such as:
"Does this passage help answer the query?"
The query becomes the shared state, while the retrieved passages become individual candidates. Jev evaluates them together and returns a probability for each one.
Application code then applies a threshold.
↳ Candidates above the threshold continue to the LLM.
↳ Candidates below it are removed from the context window.
The same Jev request can also judge whether the remaining evidence is sufficient to answer the query.
If answerability falls below the threshold, the application can skip the LLM and return "not in the documents."
Jev does not replace the embedding model, vector database, or generation model. Retrieval still sets the cap because Jev cannot recover a passage that never entered the candidate set.
The diagram below depicts the complete flow.
- RAG retrieves a broad candidate set.
- Jev reranks and gates those candidates.
- The LLM generates an answer.
If you want to dive deeper, I have also written a hands-on guide showing how to build a Jev-style model with open models, entirely locally.
Read it below.
Prasad Kodukulla retweeted
We’ve lost an icon. Margaret Hamilton, a computer science pioneer best known for her work at MIT leading development of the flight software for the Apollo missions to the moon, has died at 90. Read about her legacy via MIT News: news.mit.edu/2026/margaret-h…
Prasad Kodukulla retweeted
Gilbert Strang, an MIT professor, taught the same linear algebra course for 62 years. When he delivered his final lecture in May 2023, students from around the world tuned in online to watch.
The course is MIT 18.06 Linear Algebra. Millions of machine learning engineers, data scientists, quants, and self-taught programmers learned the essential math behind AI from his clear, free video lectures, even though most never stepped foot on the MIT campus.
Strang joined the MIT faculty in 1962 and retired in 2023. When MIT launched OpenCourseWare in 2001–2002, he was one of the first to embrace it fully. While many professors hesitated, Strang saw it as an opportunity to share mathematics with everyone. He filmed his lectures and made them freely available.
He completely changed how linear algebra is taught. Instead of starting with abstract vector spaces and proofs, Strang began with something simple and visual: matrix multiplication. He built intuition first using concrete examples, then introduced more advanced ideas like eigenvectors and singular value decomposition. He insisted that students should be able to explain every concept with a small, tangible matrix before moving to theory.
Beyond the content, his teaching style stood out. He spoke to students with genuine respect, patience, and kindness, never using words like “obviously” or “trivially.” He regularly paused to check if anyone was lost and treated beginners as thoughtfully as he would his colleagues.
As a result, Strang became the default linear algebra teacher for much of the planet. Universities in many countries began recommending his lectures to their own students. Some even replaced their in-person courses with his videos because they could not match their clarity.
His final lecture ended with a long standing ovation. Strang seemed surprised by the applause, smiled humbly, and simply thanked everyone.
In his short comment under the YouTube video, he expressed gratitude for a wonderful life of teaching and hoped others would continue teaching the subject well. No self-promotion, no grand farewell—just quiet sincerity.
When you add up every version, every upload, help sessions, and all the different recordings MIT has shared over the years, the total has surpassed 20 million views.
Today, the full course, including all lectures, problem sets, and solutions, remains freely available on MIT OpenCourseWare. One of the most important mathematical foundations of modern AI is still just one click away.
Prasad Kodukulla retweeted
Top 12 agentic use cases for Jev:
(bookmark this)
Jev handles semantic decisions that ordinary code cannot express reliably. It returns typed answers and probabilities, while code continues to cover the workflow.
Here are 12 practical use cases for Jev:
1. Browser next action
> Convert the current DOM state into a bounded action such as click, type, or stop. Code executes only valid operation-target pairs. There are already several open-source Jev web agents.
2. Context compaction
> Decide which events from a long agent trace should remain. The selected text stays verbatim instead of being replaced with a generated summary.
3. Skill and context loading
> Compare the current user turn against the available skills. Load only the instructions needed for that turn instead of filling the context window with every skill.
4. Typed tool-call compilation
> Map a natural-language request to a function and fill its typed arguments. Each argument is evaluated separately before code allows execution.
5. Citation verification
> Check whether a quoted passage exists and whether the surrounding evidence supports the claim. The output can be supported, unsupported, or contradicted.
6. Extraction verification
> Run a cheap extractor first, then use Jev to verify questionable fields. Clean records stay on the fast path while uncertain ones reach a reasoning model.
7. Agent trace evaluation
> Turn raw trajectories into queryable labels such as progress and repetition. This avoids asking another LLM to write a full review of every run.
8. Semantic regression tests
> Replay a trace suite against a new agent build. Semantic checks can then pass or block prompt, model, tool, and policy changes in CI.
9. Jevgrep code search
> Search a codebase by what the code does rather than its exact words. Jev scores candidate snippets and returns the most relevant code first.
10. Entity alignment
> Compare two candidate records and decide whether to merge, review, or keep them separate. Candidate generation remains deterministic while Jev handles semantic identity.
11. Retrieval reranking
> Let embeddings retrieve a broad candidate set, then use Jev to reorder passages by relevance. The generation model receives the most useful evidence first.
12. Memory promotion gate
> Capture a completed agent trace, then judge whether its corrections contain a reusable lesson. Trace-backed lessons can be promoted while task-specific noise is discarded.
If you want to see the final pattern in practice, it is already implemented in the Beacon open-source project.
Beacon captures full sessions across Claude Code, Codex, Cursor, OpenCode, and 20+ agent harnesses, and then Jev identifies which workflows and corrections are worth learning from, so that a lesson discovered by one agent can become available to the others.
GitHub repo: github.com/Asymptote-Labs/ag…
(don’t forget to star it ⭐)
If you want to dive deeper, I also wrote about a similar mechanism in a hands-on guide. It covers building a Jev-style decision path with open models, entirely locally.
Read it below.
Prasad Kodukulla retweeted
this is free f*cking gold for anyone still gluing agents together with loops
Andrew Ng mapped 4 agentic patterns into one graph instead of four separate tricks
Reflection, Tool Use, Planning, Multi-Agent Collaboration, one flow
User → Architect Agent → Tech Lead Agent → Developer Agent, typed handoffs
feedback loops back to the user at every stage, not just at the end
GPT-3.5 wrapped in this style of workflow: 95.1% on HumanEval. GPT-4 zero-shot: 67%.
give this to your next agent build before you touch the model card again.
Prasad Kodukulla retweeted
Andrew Ng just released a 2-hour course on full Graph Engineering.
How to go from one prompt to 100 agents that loop, improve themselves, and run without you:
0% → 09:14 - build your first AI agent
25% → 33:11 - run agents with loop engineering
50% → 1:02:46 - turn agent loops into graphs
75% → 1:30:15 - build agents that rewrite themselves
100% → 1:49:05 - run the entire graph system without you
Most people are still building one agent and calling it done.
Andrew Ng is already teaching what comes next:
Prompt → Agents → Loops → Graphs → Self-Improving Systems
Single agents are the old workflow.
Systems that improve and run without you are the next one.
This 2-hour course is worth more than most $500 agent engineering courses.
Bookmark it and watch before everyone starts catching up.
Then read how to run 1,000 agents from one prompt below ↓
Prasad Kodukulla retweeted
20 useful AI GitHub repos every software engineer should
bookmark 🔖 (you'll thank me later):
1 OpenClaw
↳ Runs a personal AI agent locally that can browse, plan & take actions on your device.
2 TensorFlow
↳ Provides a production-ready framework to build, train & deploy ML models at scale.
3 AutoGPT
↳ Automates multi-step tasks by chaining LLM reasoning into autonomous agents.
4 n8n
↳ Automates workflows with a visual builder that integrates APIs, data & AI tools.
5 Ollama
↳ Runs open LLMs locally with simple commands & optimized performance.
6 Stable Diffusion WebUI
↳ Generates images locally with a powerful UI for Stable Diffusion models.
7 Hugging Face Transformers
↳ Offers thousands of pretrained models for NLP, vision & multimodal AI tasks.
8 Dify
↳ Creates production-ready AI apps with built-in orchestration, prompts & APIs.
9 Langflow
↳ Builds & tests LLM pipelines visually using a drag & drop interface.
10 LangChain
↳ Orchestrates LLM workflows, tools, memory & agents in applications.
11 Open WebUI
↳ Delivers a self-hosted ChatGPT-style interface with local & API model support.
12 DeepSeek-V3
↳ Provides a high-performance open-weight LLM optimized for reasoning & coding.
13 PyTorch
↳ Builds & trains deep learning models with flexible, research-friendly APIs.
14 Gemini CLI
↳ Interacts with Google’s Gemini models directly from command line.
15 llama cpp
↳ Runs LLaMA-style models efficiently on CPUs & local hardware.
16 Whisper
↳ Transcribes & translates speech with high accuracy using deep learning.
17 ComfyUI
↳ Designs advanced image generation workflows using node-based pipelines.
18 CrewAI
↳ Coordinates multiple AI agents to collaborate on complex tasks.
19 RAGFlow
↳ Implements retrieval-augmented generation pipelines for enterprise search & QA.
20 Claude Code
↳ Assists coding with deep repository understanding & agent-style workflows.
What else should make this list?
1 Save & RT to help others learn AI engineering.
2 Follow @Tanaypawar27 + turn on notifications.
Prasad Kodukulla retweeted
🧬 Does a family member of a Lynch syndrome patient automatically need lifelong colonoscopies?
Not always.
The first step is predictive germline testing for the known familial Lynch syndrome mutation.
✅ Mutation-positive → Start Lynch syndrome surveillance:
• Colonoscopy every 1–2 years
• Begin at 20–25 years or 2–5 years before the earliest family colorectal cancer
• Add gene- and sex-specific screening as appropriate
❌ Mutation-negative → Follow average-risk colorectal cancer screening.
⚠️ Genetic testing unavailable? Manage as Lynch syndrome until proven otherwise.
Remember: Test first, then tailor surveillance.
#LynchSyndrome #ColorectalCancer #HereditaryCancer #CancerGenetics #GeneticCounseling #GIOncology #PrecisionMedicine #CancerPrevention #MedicalEducation #Oncology #FOAMed #MedTwitter #OncoTwitter #CancerConceptsExplained
🤖 Made with AI
Prasad Kodukulla retweeted
The future of oncology is increasingly tumor-agnostic.
Rather than selecting treatment solely based on where a cancer originated, we can now target specific genomic alterations that drive tumor growth—regardless of the tissue of origin.
Some of the most important tumor-agnostic biomarkers every oncologist should know:
🧬 MSI-H/dMMR
🧬 NTRK fusion
🧬 TMB-High
🧬 RET fusion
🧬 BRAF V600E (approved settings)
🧬 HER2 alterations (selected indications)
Comprehensive Next-Generation Sequencing (NGS) has become an essential tool to identify these actionable alterations and guide personalized treatment decisions, especially in advanced, rare, or treatment-refractory cancers.
Think molecular. Treat smarter.
The right biomarker can transform outcomes—sometimes irrespective of where the cancer began.
#Oncology #MedicalOncology #PrecisionOncology #PrecisionMedicine #TumorAgnostic #NGS #CancerGenomics #TargetedTherapy #Immunotherapy #NTRK #MSI #dMMR #TMB #RET #HER2 #BRAF #CancerEducation #FOAMed #MedEd #DrNB
🤖 Made with AI
Exciting New Agentic AI Workflow Tool for Scientists - Claude Science linkedin.com/pulse/exciting-… via @LinkedIn
2
2
75








































