It’s about choice. And it’s powerful.
I attended a training session today on setting up Databricks Genie Agents. Someone asked a great question: As you use the agent and chat with it, does it learn?
The short answer was “no.” Sure, there’s a feedback loop that users and agent authors can participate in, but the agent doesn’t automatically learn from every conversation. The instructor’s response? “Maybe AI will be there soon. Let’s check back next year.”
In the meantime… meet the agent I use with my Databricks data. One that can learn from experience: Hermes.
Chat with your data. From anywhere.
Databricks exposes a Databricks SQL MCP server. You send it SQL, and it returns the results. Simple, but very, very useful.
I connected that MCP server to Hermes and configured it to use an LLM that’s good at generating SQL. Now I can prompt it with things like:
- “What are my latest five transactions?”
- “Show me how much I spent in February by category.”
- “Compare these two accounts.”
The LLM generates a SQL query and sends it to the MCP server. The server returns the results in tabular form, and the LLM turns those results into a conversational answer.
I literally chat with my data.
The screenshot below shows both how simple and how complex your prompts can be. Prompts get interpreted and forwarded to the Databricks SQL MCP.
Okay, Genie in Databricks can do something similar. But here’s the thing: I can chat with my Databricks data from outside Databricks, using the LLM of my choice.
That means my data remains accessible to agentic business processes running elsewhere. You can build Genie agents inside Databricks and make their capabilities available across the enterprise. Or you can build agents outside Databricks that access your data through MCP.
Databricks champions cloud-agnostic storage for your data. I’m championing something similar: agent-agnostic AI for your data.
Your data platform doesn’t have to dictate which AI agent you use to get value from your data.
And there’s another option: Databricks also provides an MCP server for Genie. That lets an external agent tap into Genie’s capabilities to retrieve insights, rather than generating every query itself.
Pretty cool, right?
But wait, there’s more. Hermes learns.
Remember that original question about whether an agent learns as you use it?
Here’s where Hermes gets interesting.
In the middle of a conversation, I can tell it something like:
“Remember this pattern for future tasks and projects.”
Hermes can save that pattern as a reusable skill or in memory, depending on the task and its configuration. Later, it can retrieve and reuse what it saved.
But wait, there’s more.
Hermes can also identify useful patterns from its own work and save them as skills or memories without me explicitly asking it to do so. That’s the self-improving behavior I find particularly interesting.
To be clear, Hermes isn’t retraining its underlying AI model. It’s not fine-tuning itself after every conversation. It’s building up a collection of reusable skills and persistent memories that can help it perform future tasks.
Think of it this way: the underlying LLM provides the intelligence, while skills and memory help the agent apply that intelligence more effectively over time.
Many modern agent frameworks support skills or memory in some form. What interests me about Hermes is its ability to manage and improve these resources automatically.
The result? An agent that can become more useful over time without having to retrain its underlying model.
How I set it up
Here are two things I did that made a big difference in my environment.
1. I taught it my database schema.
I instructed Hermes to query the database’s information schema and save the relevant metadata to memory. That way, it could refer to the tables and columns when translating my English questions into SQL.
Without that context, even a powerful LLM might guess the wrong table, misunderstand a column, or generate SQL that doesn’t match the actual schema.
2. I experimented with different LLMs.
I tried models with different capabilities and levels of reasoning before settling on my current favorite: Qwen3.7 Flash.
Why that one? I wanted the cheapest model I could find that was still powerful enough to understand my schema and generate reliable SQL from natural-language prompts.
In my testing, it has been remarkably good at this task. With the schema context available, I was able to turn off explicit reasoning and let it generate SQL and call the Databricks SQL MCP directly.
No elaborate reasoning process. Just a prompt, a SQL query, and the results.
Oh, and did I mention it’s fast?
I like this model, but I’m not married to it. There’s probably an even cheaper or faster option out there, and I’ll keep experimenting.
That’s another benefit of this architecture: I can change the model without having to rebuild the entire data-access solution around it.
Give it a try!
I won’t get into all the technical details here. You can ask Hermes to help configure the MCP connection and build the necessary skills, although you’ll still need to verify the configuration and permissions.
The bigger idea is what excites me.
You can use AI to chat with your Databricks data from outside the Databricks environment, choose the model that works best for your needs, and build an agent that automagically accumulates useful skills and memories over time.
Your data. Your choice of AI. An agent that gets better at helping you. Yes, it gets better all by itself.
Now that’s cool.
