A markdown convention I wrote to track 5-10 half-built projects without losing my mind, and without another SaaS subscription.

TL;DR. AI made it cheap to generate ideas, draft plans, and start projects. It did not make it cheap to track them. I ended up with 5-10 half-built projects, plan files everywhere, no idea which were stalled vs. blocked vs. abandoned, and no way to explain status to stakeholders or even to future-me. I tried Jira, Linear, Notion, none stuck. I wrote a markdown convention for myself instead: 3 directories, 7-field frontmatter, one HTML dashboard. AI coding assistants (Claude Code, Cursor, Antigravity, Windsurf) read it natively as a side effect. Repo at the bottom.

The new bottleneck

For most of my career, the bottleneck was writing the code. Planning was the easy part. You’d think a feature through, scope it, then spend the next two weeks actually building it.

AI inverted this. I can now scope a feature with Claude in 20 minutes and have a working prototype in an afternoon. That’s genuinely transformative. But the bottleneck didn’t disappear, it moved.

The new bottleneck is knowing what I’m actually working on.

I have 5-10 half-built projects right now. Some I started with AI and never finished. Some I planned with AI and never started. Some are blocked on something I forgot. Some are stalled because I lost interest two weeks in. Some have dependencies on other half-built things, and the dependencies aren’t visible anywhere.

If you asked me “what are you actively building this week?”, I genuinely couldn’t tell you without opening five repos and reading scattered markdown files. That’s the real productivity problem AI introduced, and it’s the one no tool I tried actually solves.

What the mess looks like in practice

Concretely, in any given month, I’ll have:

• 2-3 active plans I’m working on right now
• 1-2 stalled plans I started enthusiastically and quietly abandoned around the 60% mark
• 2-3 ideas I asked AI to plan out that never moved past the planning doc
• A few “I should pick this up again” thoughts about half-built things from 2 months ago
• Dependencies between some of these that I knew when I wrote them and have since forgotten

Every one of those generates a FEATURE_X_PLAN.md somewhere. At one point I had 38 plan files at the root of one repo, none of which I could quickly classify as “alive” or “dead” without re-reading them.

The result: when someone (a stakeholder, or future-me opening the repo cold after weeks away) asked me what state things were in, I couldn’t answer. Not “I gave a vague answer”, I genuinely could not produce a clear answer without an hour of archaeological work.

What I’d tried

Jira. Worked for a week. Opening a browser tab and clicking through fields became higher friction than writing one more markdown file in the editor.

Linear. Same outcome, faster. Better UX doesn’t matter if the friction is “leave my editor”.

Notion. Lasted longer because it felt closer to writing. Sat unused after three weeks anyway. Became a third source of state, not a single source.

Pattern I missed for too long: these tools are built for teams shipping a small number of larger things in a coordinated way. That’s not what AI-assisted solo work looks like. AI-assisted work generates a larger number of smaller, parallel, shifting things with unclear states and frequent context switches. Different shape of work needs a different shape of tracking.
Forcing AI-velocity work into team-throughput tools is the wrong fit, and the friction is the symptom.

What I built instead

A convention, not a tool. Lives entirely in the repo as plain text.

Three directories:

plans/
  active/      <- what's being built right now
  shipped/     <- what's done (don't delete, keep the receipts)
  superseded/  <- what got abandoned (don't delete, keep the why)

The “don’t delete” part matters. Old plans are evidence of how a project actually evolved. Deleting them erases the history of decisions.

One file per feature, with 7 fields of frontmatter:

---
status: active
priority: P1
owner: yasiru
type: feature
depends_on: []
blocks: []
last_updated: 2026-05-17
---

The depends_on and blocks fields are the ones that quietly do the most work. Plans aren’t independent; they have a dependency graph, and the graph is what lets me see “I can’t start B until A ships.”

One STATUS.md at plans/STATUS.md that answers “where are we right now” in one place. In flight, up next, recently shipped, backlog. I open this in the morning instead of trying to remember.

One HTML dashboard (roadmap.html) that reads the auto-generated plans.json and renders an interactive Gantt + dependency graph + filterable cards. Static file, no server, no account, no login. This is the thing I send to stakeholders. They open a URL, they see what’s happening. No tool training, no permissions, no monthly seat cost. Just a webpage.

The whole convention is about 300 lines of code and lives in your repo. No service, no build step.

The AI part wasn’t the goal, but it ended up mattering

I built this for me. The primary audience is the human (often future-me) trying to remember what state 8 different projects are in.

But because the format is plain markdown with predictable structure, AI coding assistants read it natively. No integration, no MCP server, no plugin. Claude Code, Cursor, Antigravity, Windsurf, all of them just open the files and know what’s in flight.

When I start a Claude session now, it reads STATUS.md and the relevant plan files. It already knows the state. We start working in two messages instead of fifteen.

That wasn’t the goal. It’s a consequence of writing things down clearly.

The insight that made it click: AI didn’t fix my planning problem. AI made my planning problem urgent. The fix was structure I should have had all along.

What actually changed

Three things, in order of unexpected impact.

One: I can answer “what are you building this week” in 10 seconds. I open STATUS.md. The answer is there. I didn’t realise how much cognitive load I was carrying around not being able to answer that question instantly.

Two: stakeholders and future-me can see the dashboard. When someone asks about a project’s status, I send the roadmap.html link. When future-me opens a side project I haven’t touched in two months, the dashboard tells me where I left off without an archaeological dig. The dashboard is a static page, no login, works on phone. Status updates went from “I owe you a write-up” to “here’s the link, click around.”

Three: AI sessions stopped opening with 15 minutes of context. Side effect, but a big one. The AI now knows what I shipped last week without me re-explaining.

The 5-10 half-built projects didn’t go away. I still have them. But now I can see them, classify them, and consciously decide what to do with each one. Some moved to superseded/ (honest “I’m not finishing this”). Some moved to a “later” status with a reason. Some got picked up again because seeing them on the dashboard reminded me I cared.

The mess didn’t vanish; it became legible.

Where this fits in the wider trend

AI-assisted development is shifting toward spec-driven workflows. The spec, the plan, the structured intent becomes a first-class artifact that your AI assistant reads and writes against, not just a doc you wrote once and forgot.

GitHub’s Spec Kit (released late 2025) handles the per-feature spec workflow really well: define one feature, generate its spec, generate the plan, generate the tasks, execute. It’s good.

Plans is the portfolio layer for the same shift. Spec Kit answers “how do I build this one feature well”. Plans answers “what are the 8 features I’m juggling, which are alive, which are dead, which are blocked, and what’s the next thing I should pick up”. Different layer of the same trend.

If you’re already doing spec-driven work with Spec Kit (or anything similar), Plans is the thing that keeps the multi-feature view legible. If you’re not yet doing spec-driven work, Plans is a low-cost way to start, because the convention itself nudges you in that direction.

Why I’m sharing this now

Two reasons.

One: I’m genuinely curious whether this is a me-problem or a universal one. If you’re a solo dev or small team using AI coding assistants, do you also have 5-10 half-built things you can’t track? How are you managing it? I want to know if I built something useful only to me, or if this is a real shared pain that nobody’s solved.

Two: the convention is MIT and the repo is public. If it sounds useful, the install is one curl one-liner. If it doesn’t fit your workflow, that’s also useful signal for me.

Where to find it

Repo, docs, live dashboard demo, and install instructions: github.com/yrangana/Plans

If you try it, I’d love to know what works and what breaks. If you don’t try it but the problem resonates, I’d love to know how you’ve solved it yourself. Either way, drop a comment, that’s the signal I’m actually trying to gather.

Built this as a personal tool, sharing it as a convention. No business model, no roadmap pressure, just markdown files and one HTML dashboard. If a bigger player (GitHub, Anthropic, etc.) ships something better in 6 months, I’ll happily migrate. Until then, this is what I use.

AICoding #DeveloperTools #SoftwareEngineering #ProductivityTools #IndieDev #SoloFounder

The landscape of AI has shifted from “bigger is better” to “smarter is better.” We are entering the era of intelligence-per-parameter—a metric of how much reasoning power is packed into a compact model. Gemma 4, built on the latest research from Google DeepMind, brings high-level, multi-step reasoning directly to your own hardware.

This guide will show you how to build a Socratic Study Buddy—a tutor that doesn’t just give you answers but helps you think through problems—while keeping your data 100% private using a custom local web interface.

What I Built

I built a local Socratic Study Buddy application. It pairs the localized inference engine of LM Studio with a custom-built Streamlit Web UI frontend. Instead of acting as a lazy “answer engine” that does a student’s homework for them, this tool forces the underlying Gemma 4 model to plan pedagogical strategies and use structured dialogue to guide critical thinking.

Why Gemma 4 Matters for Learning

Gemma 4 is a “Thinking Model.” Older AI models functioned like advanced autocomplete, predicting the next word based on patterns. Gemma 4 has the capacity for a native Chain-of-Reasoning process.

Instead of jumping straight to an answer, Gemma 4 works through logical steps internally before it speaks. This makes it a perfect mentor. While other models might just do your homework, Gemma 4 is trained to identify where you are stuck and nudge you toward the solution.

Choosing Your Brain: The Official Model Sizes

To run this locally, you need to pick the right “size” for your computer. Gemma 4 comes in four official variants:

• Effective 2B (E2B): Tiny and lightning-fast. Optimized for high-end phones or older laptops with 4GB–8GB of RAM.

• Effective 4B (E4B): The “Sweet Spot” for most modern laptops with 8GB–12GB of RAM. This is the entry point for high-quality image and audio understanding.

• 26B A4B (Mixture-of-Experts): The speed demon. It has 26 billion parameters but only uses 4 billion at a time to answer. You get high-quality reasoning with fast speeds. Requires 16GB–24GB of RAM.

• 31B Dense: The flagship. This is the smartest model in the family, providing maximum reasoning quality for complex math. Use this if you have a powerful workstation with 32GB+ of RAM.

Setup: Bringing the Brain to Your Frontend

Instead of staying restricted to standard desktop setups, we bridge the model into a lightweight web dashboard.

Step 1. Weight Retrieval & Backend Hosting

1. Search for Gemma 4: Open LM Studio and click the Magnifying Glass. Type "Gemma 4".

2. Select a GGUF: Look for files labeled GGUF (a compressed file format that lets heavy models run on consumer hardware).

3. Choose Your Quantization: Look for Q4_K_M (a version that balances intelligence with low memory usage).

4. Start the Local Server:: Head to the Local Server tab in LM Studio, load your downloaded model, ensure your system prompts are injected, and start the service on port 1234. Turn GPU Offload to “Max” to leverage your graphics card.

Step 2. Running the Custom Web UI

To spin up the clean web chat interface shown below, clone the repository, install the dependencies, and launch the frontend file:

pip install streamlit openai
streamlit run app.py

Demo

Here is how the complete architecture interacts within the custom Python frontend workspace:

The UI Environment Overview

The implementation splits backend configuration details directly away from the active learning space, allowing seamless swaps between running models:

The Project: The Socratic Study Buddy Prompt

In your local configuration workspace or the core application prompt files, we pass this instruction using the official <|think|> control token sequence to isolate the reasoning channel:

<|think|>
You are an expert academic tutor. You are forbidden from giving the final answer. Instead, use your internal reasoning to identify the core concept the student is struggling with and ask guiding questions.

The “Thinking” Advantage in Action

When you ask the web component: “I don’t understand how recursion works in coding.”

Gemma 4 enters its Internal Thought Channel. Within your local terminal execution or dashboard view, you will see it process its strategy before printing its output:

Gemma 4 (Internal Reasoning): The user wants to know recursion. Giving code directly violates the Socratic constraint. I will use a structural stack analogy, like a line of people or nesting boxes, to force them to identify the concept of a terminating condition.

Tutor Output Response:

“To understand recursion, we first need to understand a ‘base case.’ If you were standing in a line of people, how would you know your position without counting everyone yourself?”

Beyond Chat: Real-World Visuals

One of the best ways to study is to visualize logic. You can ask your Study Buddy to "Draw the logic of this concept." It will generate clean Mermaid.js code directly in the conversation panel:

User: “Show me the logic of the Socratic method we just used.”
Gemma 4: “Here is the flowchart of our session:”

graph TD
    A[Student Asks Question] --> B{Model Thinks}
    B --> C[Identify Missing Concept]
    C --> D[Ask Guiding Question]
    D --> E[Student Responds]
    E -->|Correct| F[Nudge to Next Step]
    E -->|Incorrect| G[Simplify Analogy]

Code

The entire layout—including the Python automation scripts, system prompt templates, configurations, and the Streamlit frontend architecture—is completely open-source:
👉 Check out the GitHub Repository Here

Digital Sovereignty & Ethical AI Safety

Building with open-source models like Gemma 4 is a foundational ethical choice:

• Privacy (Digital Sovereignty): Every question you ask stays on your machine. Your learning struggles aren’t being used to train a corporate model.

• The Trade-off: Unlike cloud models, a local model is your responsibility. You must verify its facts, as it doesn’t have an external “safety filter” monitoring the conversation.

Advantages:

• Transparency: You can inspect the weights and the “thinking” process, which is impossible with closed-source models.

• Privacy: Since it runs locally in LM Studio or on your private GKE cluster, your data never leaves your environment.

Disadvantages:

• Resource Intensity: High-reasoning models still require significant compute power compared to lightweight “dumb” bots.

• Guardrail Responsibility: Unlike a managed API that filters every word, an open-source model places the “Safety Filter” responsibility on you. You must implement your own output classifiers to ensure the model stays within educational boundaries.

Conclusion

You’ve gone from raw local model files to running a custom, world-class educational reasoning platform directly on your laptop. You’ve built an app that doesn’t just echo stored training text—it actively fosters critical thinking.

Your Challenge: Use your newly built Web UI Study Buddy to tackle a topic you’ve always found intimidating—maybe organic chemistry or financial engineering. How does having an interface powered by a “Thinking Model” change the way you interact with complex documentation?

Next Steps: Ready to scale from a chat interface to fully autonomous pipelines? Check out the Pi Coding Agent by Patrick Loeber—a minimal terminal client that bridges local Gemma 4 instances straight to your terminal environment so it can write, debug, and run code directly for you!

From a working prototype to something that actually behaves like a real system.

Introduction

In the previous parts, we built a fairly solid RAG pipeline:

• Vector search using FAISS
• Better chunking strategies
• Context optimization
• HyDE for improving retrieval quality

At that point, the system worked. It could answer questions from a document.

But it still didn’t feel right.

If you’ve used systems like ChatGPT, you know the difference immediately. The answers are not just correct — they are contextual, conversational, and consistent across turns.

Our RAG system wasn’t there yet.

What was still missing?

A few practical issues started showing up:

• Follow-up questions like “explain more” didn’t work well
• Queries without enough context failed silently
• Retrieval sometimes returned semantically similar but irrelevant chunks
• There was no clear way to debug why something went wrong

This part focuses on solving exactly those problems.

Goal for this part

Move from:

Query → Retrieve → Answer

To something closer to:

Understand → Retrieve → Validate → Answer → Debug

1. Conversational Retrieval

A basic RAG pipeline treats every query independently. That works for demos, but not for real usage.

Users don’t ask perfectly structured questions every time. They ask things like:

• “Explain this”
• “Continue”
• “What does that mean?”

Without context, these queries are meaningless.

Making queries context-aware

Instead of using only the current query, we include recent conversation history.

You’re already doing this in two places.

HyDE (used with context)

def generate_hypothetical_answer(query, chat_history):
    recent_user = [m["content"] for m in chat_history[-4:] if m["role"] == "user"]
    history_text = " | ".join(recent_user[-2:])

    prompt = (f"Write a 2-sentence technical summary answering: {query}n"
              f"Recent user context: {history_text}")

    response = ollama.generate(model=HYDE_MODEL, prompt=prompt, stream=False)
    return response['response']

This makes the generated “hypothetical answer” more aligned with the conversation, not just the current query.

Passing conversation into the final answer

history_text = "n".join([
    f"{history['role']}: {history['content']}"
    for history in chat_history[-5:]
])

This allows the model to generate responses that are consistent across turns.

Result

• Queries become less brittle
• Retrieval improves for vague inputs
• Responses feel connected instead of isolated

Conversational Retrieval Flow
(User query + history → query enhancement → retrieval → answer)

2. Page-Aware Search

One thing becomes very obvious once we start testing real documents:

Not every query should be handled using semantic search.

The problem

If a user asks:

“What is written on page 5?”

A pure vector search might return:

• Content from page 3 that looks semantically similar
• Completely miss the actual page

This is technically “correct” from a similarity perspective, but practically wrong.

The fix: introduce a deterministic path

Instead of forcing everything through FAISS, we add a second mode.

Detecting page intent

page_match = re.search(r"pages+(d+)", query.lower())
target_page = int(page_match.group(1)) if page_match else None

Restricting search space

allowed_pages = [target_page - 1, target_page, target_page + 1]

candidates = [
    item for item in text_metadata
    if item["page"] in allowed_pages
]

Why this works well

• removes ambiguity
• reduce noise in retrieval
• align results with user intent

It’s a simple idea, but it has a big impact on reliability.

Final behavior

• Page-specific queries → deterministic filtering
• General queries → semantic search (FAISS + rerank)

Page-aware vs Semantic Flow

3. Handling Follow-Up Queries

This is where the system starts to feel more natural.

The problem

A query like:

Explain more

has no standalone meaning.

Without additional context, retrieval either fails or returns random results.

Detecting vague queries

vague_followups = re.compile(
    r"^(explain(s+w+){0,3}|elaborate|tell me more|go on|continue|...)",
    re.IGNORECASE
)

Injecting context from previous answers

last_pages = get_last_referenced_pages(st.session_state.messages)

if last_pages:
    page_inject = last_pages[len(last_pages) // 2]
    query = f"{query} page {page_inject}"

What this achieves

A vague query like:

Explain more

gets transformed into something like:

Explain more page 5

Now retrieval has something concrete to work with.

Result

• Follow-up queries become usable
• Conversations feel continuous
• Retrieval remains grounded in the document

Follow-up Handling Flow

4. Debugging the RAG Pipeline

This is probably the most important upgrade in this part.

Most RAG systems fail not because they are fundamentally broken, but because we can’t see what’s happening inside them.

The usual situation

We get a wrong answer and we don’t know:

• Was the query bad?
• Was retrieval wrong?
• Did reranking fail?
• Did the model hallucinate?

Everything looks like a black box.

Adding visibility

So, we introduce a debug layer that exposes each stage.

1. Query transformation

debug_data["query"] = query
debug_data["search_query"] = search_query

This lets us compare:

• Original query
• Final query used for retrieval (after HyDE / modifications)

Here’s what this looks like in practice:

2. FAISS retrieval results

distances, indices = index.search(query_vector.reshape(1, -1), k=FAISS_SEARCH_K)

Here’s what this looks like in practice:

3. Reranking results

results = ranker.rerank(RerankRequest(query=query, passages=rerank_items))

Here’s what this looks like in practice:

4. FAISS vs rerank comparison

This is where things get interesting.

We can now see cases where:

• FAISS ranks something high
• Rerank pushes it down

Or vice versa.

Here’s what this looks like in practice:

5. Score distribution

ax.plot(faiss_scores, label="FAISS")
ax.plot(rerank_scores, label="Rerank")

Here’s what this looks like in practice:

Why this matters

Now when something goes wrong, we can actually trace it:

• If FAISS results are bad → embedding / chunking issue
• If FAISS is good but rerank is bad → rerank model issue
• If both are good → prompt or answer generation issue

This turns debugging into a structured process instead of trial and error.

Final Architecture

Conclusion

At the beginning of this series, we had a simple goal: understand how RAG works by building it ourselves.

Over time, that evolved into something more practical.

We now have a system that:

• Handles conversational queries
• Deals with vague follow-ups
• Respects document structure
• Provides visibility into retrieval

More importantly, It’s no longer a black box — it’s a system you can reason about.

What changed

We moved from a basic pipeline:

Search → Answer

to something closer to:

Understand → Retrieve → Validate → Explain → Debug

Where this leaves us

This is no longer just a learning project. It’s a foundation we can build on.

What’s next

In the next series, we’ll move beyond retrieval and look at something more powerful:

• Tool-using AI systems
• Offline LLM capabilities
• Building agents that can take actions

Code

Main branch:
https://github.com/SharathKurup/chatPDF

If you’ve followed along from Part 1 to here, you’ve already done the hard part — building the system from scratch and understanding how it behaves.

From here, it’s no longer about understanding RAG — it’s about building on top of it.

Note:
This article represents my personal views and not those of Snowflake.

Information regarding Snowflake Summit 26

Snowflake Summit 26 will be held in San Francisco from June 1 to June 4, 2026. Various updates are expected to be announced, so please stay tuned.

Snowflake Summit 26

Explore the future of data, AI, and applications at Snowflake Summit 26. Join experts, attend workshops, and get SnowPro certified while learning new data trends.

snowflake.com

I am planning to attend in person, so I look forward to meeting anyone who will be there!

Introduction

As mentioned at the beginning, Snowflake Summit 26 is finally approaching next month. In this article, I would like to provide an overview of the current standing of Snowflake – The AI Data Cloud from an AI perspective and broadly organize the situation as of May 17, 2026. In my professional role, I have had many opportunities to discuss these topics recently, so I decided to verbalize them in an article. Please note that this article is intended to summarize the overall picture and may not cover every single detail. Let us dive in!

There is No AI Strategy Without a Data Strategy

“There is no AI strategy without a data strategy” – Interestingly, the reason I chose to join Snowflake about a year ago was very close to this. Even then, there were many requests to utilize AI in the enterprise, but I felt that a well-organized and easy-to-use data foundation was necessary for that. Recently, keywords like ChatGPT and Claude have become common, but these services—and the models behind them—do not inherently possess the “context of the company trying to use them” in their raw state. They become more useful within a company by combining them with internal data. However, to do so, it is necessary to prepare the data foundation and utilize it as appropriate context.

Given this situation, I believe “There is no AI strategy without a data strategy” is a keyword that truly captures the essential point.

Two Pillars of AI Utilization in Snowflake

Regarding how AI can be utilized in Snowflake under these circumstances, I believe there are two main pillars. These are “Making data AI-Ready/analyzable” and “Using AI-Ready data.”
In the diagram above, these correspond to the left and right sides of “AI Ready GOLD.” Let me organize these two pillars below.

AI Utilization for Making Data AI-Ready/Analyzable

Snowflake is expanding its features to enable the use of AI in various ways to make data AI-Ready or analyzable.

Data Engineering Perspective

It is said that 80% of the world’s data is unstructured data, such as images, videos, and PDFs. Snowflake is also expanding various functions to handle this unstructured data. By using features like AI Functions and the Document Processing Playground, it is possible to convert unstructured data into analyzable data.

AI Functions include the following types of functions:

By using these, for example, it is possible to perform the following processing based on audio recording data:

This allows various data points to be generated from a single recording and treated as analytical dimensions.

Handling Document Data

Furthermore, it is now possible to handle various document data, including PDFs. By using the AI_PARSE_DOCUMENT function, the following conversion process can be performed:

AI_PARSE_DOCUMENT supports various file formats such as PDF, PPTX, DOCX, JPEG, JPG, PNG, TIFF, TIF, HTML, and TXT.

An update on May 4, 2026, enhanced the OCR mode of AI_PARSE_DOCUMENT, improving the accuracy of OCR mode and multilingual support. Please give it a try.

May 04, 2026: AI_PARSE_DOCUMENT OCR quality improvements

Additionally, the Document Processing Playground feature has been released. This feature helps you by suggesting what SQL or Python code to write when uploading document data to extract necessary information.

Updates for these functions handling document data are frequent, and features such as figure/table extraction have recently been released. These functions are also introduced in the following blog posts (Note: Links are to Japanese articles).

• Extracting images and text from PDFs with Snowflake Cortex AI_PARSE_DOCUMENT and analyzing with multimodal AI
• Analyzing PDFs, Word, and Excel with tables/figures directly using AI_COMPLETE with documents

By vectorizing the data extracted using these functions, semantic search based on meaning becomes possible. This can be used with the Cortex Search feature, which will be described later.

Handling PII (Personally Identifiable Information)

The AI_REDACT AI Function for processing personal information has also been released.
This function identifies and masks PII contained within text. The image below illustrates the concept:

Handling Video and Audio Data

Additionally, as of May 6, 2026, although in Public Preview (PuPr) status, it has become possible to directly handle video and audio data using specific models in the AI_COMPLETE function. While there are limitations on models and file sizes, the patterns for approaching unstructured data have increased further.

May 04, 2026: Multimodal video and audio analysis for marketing and brand insights (Public Preview)

A detailed analysis of the results can be found in the blog post “Beyond Transcription – Multimodal Video and Audio Analysis with Snowflake AI_COMPLETE” so please take a look.

Regarding audio data, it was already possible to convert it to text using the AI_TRANSCRIBE function, but the variations have now expanded.

A great advantage of these AI Functions is that they can be executed as part of SQL close to the data, allowing for efficient processing of large volumes of data.
In this way, Snowflake provides various services for handling unstructured data, enabling conversion into AI-Ready and other easily analyzable formats. I believe this reflects a design philosophy of “AI utilization close to the data.”

AI Utilization for People and Systems to Use AI-Ready Data

For data organized in the manner described above, Snowflake provides various ways to utilize that data. While traditional data handling using SQL and BI tools remains possible, AI has come to play a significant role in the data utilization field. Snowflake provides the following major services as related functions:

• Services for searching data: Cortex Search, Cortex Analyst
• Services for developing arbitrary AI Agents to search data or gain insights: Cortex Agents
• Applications for working with data: Snowflake Intelligence, Cortex Code in Snowsight / CLI
• Integration with other AI tools: Snowflake-managed MCP Server

Services for Searching Data

Cortex Search

Cortex Search is a hybrid search service supporting both keyword and vector search. Cortex Search is receiving useful updates, such as Cortex Search Multi-index and Index-specific Boosts to enhance search flexibility and accuracy, as well as Cortex Search Batch, which covers use cases for processing large volumes of queries in batches, such as entity resolution, catalog mapping, and deduplication.

Cortex Analyst

Cortex Analyst is a service for achieving Text-to-SQL (converting natural language into SQL). It utilizes defined Semantic Views and leverages AI to perform searches against table data.
In analytical tasks and AI-Ready data utilization, the Semantic Layer is a crucial element. In Snowflake, this feature is named “Semantic View,” allowing for the organization of metadata such as logical tables, analytical dimensions, and items to be aggregated. Additionally, Snowflake has a feature called Semantic View Autopilot that automatically generates these “Semantic Views.” Currently, generation is in English, so care is needed, but it is a feature that assists in the often labor-intensive task of preparing Semantic Views.

A part of the Semantic View Autopilot feature includes automatically generating Semantic Views by importing definition information from other tools. For example, it can read a Tableau Workbook to automatically generate a Semantic View.

Furthermore, Snowflake is advancing an initiative called the Open Semantic Interchange (OSI) Initiative, working with various partners to standardize the Semantic Layer. The repository for this activity is below:

open-semantic-interchange/OSI

Services for Developing Arbitrary AI Agents to Search Data or Gain Insights

Cortex Agents

Cortex Agents is a service for building AI Agents on Snowflake. It functions as an AI Agent that operates by linking data search services like Cortex Search and Cortex Analyst with custom tools such as stored procedures. In a recent update, Cortex Agents added support for Agent skills, improving execution efficiency for repetitive tasks, and support for MCP Connectors, allowing integration with external tools and services.

Cortex Agents can be used not only within Snowflake Intelligence but also via REST API or through a Snowflake-managed MCP Server, allowing calls from any application or AI Agent.
Examples of integration include:

• Integration with Teams/Microsoft 365 Copilot: Cortex Agents for Microsoft Teams and Microsoft 365 Copilot
• Integration example with Amazon Q (Simple hands-on): Multi-Agent Supply Chain Orchestrator with Snowflake Cortex MCP and Amazon Q Business
• Integration example with Microsoft AI Foundry (Simple hands-on): Multi-Agent Agentic Orchestrator with Snowflake Cortex MCP and Microsoft AI Foundry

Recently, on April 13, 2026, an update was made allowing Cortex Agents to directly reference Semantic Views and generate SQL without going through Cortex Analyst. This update is expected to improve the accuracy of analytical queries and reduce latency.

Apr 13, 2026: Improved SQL generation in Cortex Agents

Applications for Working with Data

Snowflake Intelligence

Snowflake Intelligence is a service that allows users to perform deep dives into data by querying the organized data foundation on Snowflake using natural language. Cortex Agents operate behind this application. With the support for Agent Skills and MCP Connectors mentioned above, these can also be utilized within Snowflake Intelligence. Furthermore, as mentioned in recent press releases, there are many feature updates for business use, such as the DeepResearch feature for in-depth investigations (scheduled for PuPr soon) and the Artifact feature for managing and sharing generated charts and tables (scheduled for GA soon).

Snowflake Intelligence is also used internally at Snowflake, with over 6,000 members across various roles using the tool. A behind-the-scenes look at this build has been published on Medium as “From Data Maze to Intelligence Layer: GTM AI Assistant with Semantic Views on Snowflake Intelligence“.

Cortex Code in Snowsight / CLI

Cortex Code in Snowsight / CLI is an AI Agent tool that supports various development tasks on Snowflake. In addition to such tasks, it can be used for data discovery via Horizon Catalog (Snowflake’s native catalog feature), allowing for data exploration using Cortex Code against the data organized on Snowflake.

Similar to Snowflake Intelligence, Cortex Code is utilized by internal members at Snowflake. The appearance of these AI tools seems to have increased the utilization of the internal data foundation. In fact, I have personally started using Cortex Code frequently to utilize internal data.

Recent updates for Cortex Code include:

• Support for more external data systems like AWS Glue, Databricks, and Postgres
• Support for MCP and Agent Communication Protocol (ACP)
• New VS Code extension (in Private Preview) and Claude Code plugin
• New Agent Software Development Kit (SDK) supporting Python and TypeScript, allowing Cortex Code features to be integrated directly into your own apps or workflows
• Updates to Cortex Code on Snowsight:
  • Cloud Agents (in Private Preview) allow users to execute code and run workflows directly in the browser
  • New Plan Mode allows for previewing and approving workflows before execution
  • Snap & Ask feature allows direct interaction with data artifacts like charts and tables

For Claude Code users, please try the snowflake-cortex-code plugin mentioned above.

Snowflake Cortex Code – Claude Marketplace

Integration with Other AI Tools

Snowflake allows several functions to be published as a Managed MCP Server on Snowflake.

This MCP Server can be used as a remote MCP Server. It can be utilized from AI Agent tools acting as MCP Clients, including ChatGPT, Claude Desktop, and Claude Code.

Security and Governance Supporting AI Utilization

The above summary focused primarily on AI for data utilization on Snowflake. Snowflake also covers security and governance elements in this AI utilization. As the use of AI advances further, these elements will become extremely important.

I personally consider Snowflake RBAC (Role-Based Access Control) to be very powerful. As shown in the diagram above, when using various services and features related to AI, the same RBAC managing the data is applied, and access control is performed based on the roles linked to the user. Since all answers reflect only the data the user has permission to view, it is possible to utilize AI and data under appropriate governance.

Furthermore, Snowflake has observability features centered on AI Observability. For example, various logs related to Cortex Agents are managed here. Additionally, a quality evaluation feature called Cortex Agents Evaluation has been released, allowing for the quality assessment of AI Agents using the GPA framework. The GPA framework evaluates AI Agent quality based on Goal (is the user’s objective eventually achieved?), Plan (do planning and re-planning provide effective high-level instructions?), and Act (do the agent’s actions follow the plan, call tools appropriately, and progress toward the goal?).

From a budget management perspective, budget management features for Cortex Agents / Snowflake Intelligence have been released (GA on April 10, 2026). This allows for:

• Flexible tag-based scope settings – management by department or project
• Multi-stage threshold settings – defense-in-depth combining ACTUAL and PROJECTED
• Automated access control – automatic response when thresholds are reached
• Cycle-based management – automatic reset/recovery at the start of the month

Other features like row-level policies also serve as a foundation, with various AI-related elements being built upon them.

Updated on May 17, 2026

On May 14, 2026, Cortex AI Guardrails expanded its support beyond Cortex Code to include Snowflake Intelligence and Cortex Agents. Cortex AI Guardrails is part of the Snowflake Horizon Catalog and is designed to use context-based reasoning to detect and neutralize threats such as indirect prompt injections embedded in tool calls. Although the configuration is applied at the account level, it can be easily enabled by changing the AI_SETTINGS parameter.

May 14, 2026: Cortex AI Guardrails support for Snowflake Intelligence and Cortex Agents (General availability)

This enhancement enables you to use these capabilities even more securely, so we encourage you to consider adopting it as well.

Conclusion

Recently, the paper that marked the beginning of Snowflake, “The Snowflake Elastic Data Warehouse,” received the SIGMOD Test-of-Time Award.

I personally feel that the evolution of Snowflake as a service over the years is proving its worth in the current era of AI.
In transforming enterprise operations, data and AI are inseparable. Snowflake provides Cortex AI based on the concepts of being easy, efficient, and trusted. I hope you will fully utilize Snowflake’s capabilities as a platform where you can easily and efficiently leverage AI while maintaining governance and security close to your data.
Snowflake has many feature updates, and it is difficult to cover them all, but I hope this article helps you grasp the overall current state of AI utilization in Snowflake.

And as mentioned at the beginning, Snowflake Summit 26 will finally be held from June 1 to June 4, 2026. I am very much looking forward to what will be announced!

Appendix

Snowflake server release notes and feature updates

Recent feature releases are summarized on this page. Please take a look.

Snowflake What’s New Distribution (by tsubasa-san)

tsubasa-san distributes update information for Snowflake’s “What’s New” on X. Please follow to catch up on the latest information.

Japanese Version

Snowflake What’s New Bot (Japanese)

English Version

Snowflake What’s New Bot (English)

Japanese version

Snowflake Summit 26 直前: AI 軸で見る Snowflake – The AI Data Cloud の現在地

zenn.dev

Revision History

May 17, 2026: Initial post

I am a bit tired of skip the license process on all tools, when I want to use some tools I need to use my TC or use the app in a poorly experience, that is the reason I created “knock”, I’ll be honest, the tool is for me, but I hope maybe could be useful for you, some screenshots are bellow

Tools

JWT validator

Base64

Typical requests view

Version your workspace and share

Use git to manage your projects

k8s

Some extra tools for k8s, like Kubeconfig manifest encripted, and allow you to organize that chaos. Load a shell with your cluster and the shell allows mouse-based cursor positioning.

If you read at this point, please give me a ⭐️ in the repository, you have not idea how important is this for all opensource contributors 🤗

Install

Desktop app — Quick install (Linux / macOS)

One-liner. Resolves latest release, downloads the right asset for your OS/arch, installs it, and (after confirming) strips macOS Gatekeeper quarantine.

curl -fsSL https://raw.githubusercontent.com/jairoFernandez/knock/main/scripts/install-app.sh | bash

Pin a version:

curl -fsSL https://raw.githubusercontent.com/jairoFernandez/knock/main/scripts/install-app.sh | bash -s -- --version v0.1.0

Linux: defaults to .AppImage. Switch to .deb or .rpm (require sudo):

curl -fsSL https://raw.githubusercontent.com/jairoFernandez/knock/main/scripts/install-app.sh | KNOCK_APP_FORMAT=deb bash

Desktop app — Quick install (Windows)

PowerShell. Downloads .msi and runs it.

iwr https://raw.githubusercontent.com/jairoFernandez/knock/main/scripts/install-app.ps1 | iex

Silent install:

$env:KNOCK_SILENT = "1"
iwr https://raw.githubusercontent.com/jairoFernandez/knock/main/scripts/install-app.ps1 | iex

apps/knock-app    Tauri 2 desktop app (React + Vite frontend)
crates/knock-cli  knock CLI binary
crates/knock-core Shared core library

curl -fsSL https://raw.githubusercontent.com/jairoFernandez/knock/main/scripts/install.sh | bash

curl -fsSL https://raw.githubusercontent.com/jairoFernandez/knock/main/scripts/install.sh | bash -s -- --version v0.1.0

curl -fsSL https://raw.githubusercontent.com/jairoFernandez/knock/main/scripts/install.sh | KNOCK_PREFIX=/usr/local/bin bash

export PATH="$HOME/.local/bin:$PATH"

iwr https://raw.githubusercontent.com/jairoFernandez/knock/main/scripts/install.ps1 | iex