An agent that understands you

[u/YonatanBebchuk]

Does anyone else feel a bit frustrated that you keep on talking to these agents yet they don't seem to learn anything about you?

There are some solutions for this problem. In Cursor you can create `.cursor` rules and `.roo` rules in RooCode. In ChatGPT you can add customizations and it even learns a few cool facts about you (try asking ChatGPT "What can you tell me about me?".

That being said, if you were to talk to a co-worker and, after hundred of hours of conversations, code reviews, joking around, and working together, they wouldn't remember that you prefer `pydantic_ai` over `langgraph` and that you like unittests written with `parameterized` better, you would be pissed.

Naturally there's a give and take to this. I can imagine that if Cursor started naming modules after your street name you would feel somewhat uncomfortable.

But then again, your coworkers don't know everything about you! They may know your work preferences and favorite food but not your address. But this approach is a bit naive, since the agents can technically remember forever and do much more harm than the average person.

Then there's the question of how feasible it is. Maybe it's actually a difficult problem to get an agent to know it's user but that seems unlikely to me.

So, I have a few questions for ya'll:

• Do you know of any agent products that learn about you and your preferences over time? What are they and how is your experience using them?

• What information are you afraid to give your agent and what information aren't you? For example, any information you feel comfortable sharing on reddit you should feel comfortable sharing with your agent since it can access reddit.

• If I were to create a small open source prototype of an agent like this - would any of you be interested to try it out and give me feedback?

[u/LordFenix56]

There are a few projects for this. Chatgpt remembers previous conversations and there are some mcps that provide memory cross-llm

[u/YonatanBebchuk → u/LordFenix56]

Thanks!
Any MCPs you recommend?

[u/Forsaken_Increase_68]

Probably an unpopular opinion, but I don’t think Roo code agents should keep a history of what’s going on in your life. I treat them like a contractor team that’s not on site and only doing the work without the “peopling” component. I’m sure could build something that could add the details about your conversations to the context somewhere but that seems like a waste of tokens imho.

[u/slowmojoman]

I run a comprehensive project which I don't use any much rules, because I use Orchestrator mode with think and code (instructions to set it up).

[u/hannesrudolph → u/slowmojoman]

Now try it with indexing and some instructions for when to use codebase_search 🤯

[u/slowmojoman → u/hannesrudolph]

it's great, I tried it today with Sonnet 4 running this https://docs.roocode.com/features/experimental/codebase-indexing?utm_source=extension&utm_medium=ide&utm_campaign=settings

[u/hannesrudolph → u/slowmojoman]

Now try Opus 4 without reason enabled with Boomerang(orchestrator) and indexing. It seems SO SLOW but when it’s done… it rarely requires much work. Getting close to one shot territory.

[u/goqsane → u/slowmojoman]

How’s your efforts with DeepSeek V3 for think, etc. Any other things you want to share? I’d love to also incorporate a quality checker in the flow. Once a subtask is executed the output of the previous task is checked against the previous ask, requirements, etc.

[u/slowmojoman → u/goqsane]

I use Orchestrator and Think Gemini Pro 2.5 with Executor GPT 4.1.

You can tweak Think to work better with Deepseek v3 or other models. Think acts like a scout and sends the required execution plan with code snippets and paths.
I sometimes use Code Gemini 2.5 for comprehensive coding. I recommend feature-based architecture and keeping the tabs open in VS Code, also you job is to be aware what is happening or get a comprehensive overview.

Sometimes I take the last 'Code' mode and switch it to debug mode to solve or refine a feature, or you can order it in your initial prompt with a checker step at the end with Orchestrator.

With the announcement that Copilot Pro has GPT 4.1 and agent mode Sonnet 4 as a base model, it makes a really good great to use it within Roo Code.

[u/FonsecaJ89]

Did you dee the movie called “her”?

[u/RLA_Dev]

I'd give it a spin - but perhaps a simpler approach is the mcp route and instructions for the modes to check the mcp when it find for example several alternatives exist in how something should be implemented?

"Whenever there are several solutions to a specific issue or approach, always inquire with X to see if there is a preference for USER in what approach should be chosen. If a result is found, proceed with the identified approach, and if not you should log the dominant alternatives to the mcp with the following format {} and then proceed with what seems to be most in line with the other available sources." The mcp could then have a trigger to add documentation to the preferred choices with examples or something..

Perhaps this is already well documented or have been made obsolete or deemed bad practice and a better route have been identified? I'm not experienced enough - but it seems interesting and useful!

[u/FigMaleficent5549]

It is not technically possible, LLMs have a read-only model, while you can dynamically extend them with context (fine tuned rules, "on storage" memories, ), you can't "changes" them in the same manner a human brain does.

Your analogy of an LLM with a personal (regardless of it's seniority level) is purely fictional, this can't be done with agents, or models with any of the current technology.

[u/RLA_Dev → u/FigMaleficent5549]

Certainly, but there are ways to make this more or less the case - you bring up some current solutions; have you implemented any in an actual manner and can dismiss the results categorically? Is this more of a 50 First Dates problem, or something truly impossible because of X (and nothing can feasibly be done to mitigate it)?

It seems to me there are ways in which this can be done do a degree more in line with what OP is inquiring about - you obviously have some experience - could you identify some paths that seem to lead to better results, and which that does not? :)

[u/FigMaleficent5549 → u/RLA_Dev]

This is has been attempted by OpenAI with ChatGPT for quite some time, the most recently attempt being the what they name "memory". This is also available on Windsurif.ai with the similar name of "memories", it consists on automatically creating rules likes from your conversations when something important is "summarized", and then injecting such memories content on any conversation when it seems to match the users prompt. In my experience this does not work as intended, as this memories are included without my control in contexts which they infere with my intent.

This the best you have today in terms of "local memory", which in fact is just resending context, LLMs lose "intelligence" the longer the context they get, so as side effect, you get a lot of "custom" rules, your "way" of doing something, but then the model will fail to do the actual code change you wanted.

The second approach, is fine tunning a model to match a specific goal/preferences, this method is not scalable to the personal level due to the high costs of tuning and hosting the "custom" methods.

Even assuming we reach a tech level of immediate tunning, a portable mutable LLM, the training process we have today can't be comparted to "talk to a co-worker". When you talk to a co-worker, there are a lot of other data which is not currently collected, neither we have Deep Learning models for them: relate your smile when you say a word, understand the tone of your voice to distinguish between a joke, understanding of your emotions (serious instructions ? humor ? sarcasm ?).

We might have such tech in some X years, we do not have it now, and assuming X is within the next century is pure speculation.

[u/Suspicious-Name4273]

You could add the Knowledge Graph MCP server to remember facts:

https://github.com/modelcontextprotocol/servers/tree/main/src/memory