Skip to content
Notifications
Clear all

The 'memory' feature is useless for our weekly syncs. It forgets key decisions.

20 Posts
20 Users
0 Reactions
216 Views
(@cloud_ops_learner_99)
Honorable Member
Joined: 5 months ago
Posts: 495
Topic starter   [#29067]

Has anyone else here in Kling Reviews run into this? We've been trying to use the 'memory' feature for our weekly cloud operations syncs. It's supposed to keep track of decisions, but it keeps dropping critical ones.

For example, last week we decided on a specific security group rule change for our bastion host. I said something like "Okay, so we're only allowing access from the office IP range, 203.0.113.0/24, and we'll implement that via Terraform." This week, when I asked Kling to recap, it had no record of that decision 😓. We had to dig through old chat logs. Makes the feature feel unreliable for anything important. Is there a trick to making it work, or is it just not ready for technical project tracking?



   
Quote
(@catherine9)
Reputable Member
Joined: 4 months ago
Posts: 298
 

I've observed similar inconsistencies, though my troubleshooting suggests it's less about the feature's readiness and more about its interaction model. The memory function seems to prioritize declarative statements over conversational ones.

Your example, "Okay, so we're only allowing access...", while clear to a human, might be interpreted by the system as part of a discussion flow rather than a final directive. In our team's trials, we found that explicitly formatting key decisions in a structured way at the end of a conversation prompts more reliable storage. For instance, we'd append: "Decision: Restrict bastion host SG to 203.0.113.0/24. Action: Update Terraform module vpc-bastion."

Have you experimented with that kind of explicit framing? It adds overhead, but until the context window handling improves, it creates a more deterministic trigger for the memory system. The underlying issue appears to be the model's difficulty in distinguishing between provisional brainstorming and ratified outcomes in free-form dialogue.



   
ReplyQuote
(@gracec)
Reputable Member
Joined: 4 months ago
Posts: 315
 

Yeah, I've run into the exact same frustration with trying to use it for our sprint planning decisions. Your example is spot on. The feature seems to treat everything as transient conversation unless you hit it over the head with a very specific command.

What worked for us was creating a separate, dedicated "decisions" channel. At the end of the sync, someone literally types "Add to memory: Decision to restrict bastion host to 203.0.113.0/24. Owner: Alex. Deadline: EOW." It's an extra step, but it forces the system to save it as a discrete fact. I've given up on it autonomously picking things out of a fluid discussion, especially for technical details like IP ranges.


The right tool saves a thousand meetings.


   
ReplyQuote
(@helenr)
Honorable Member
Joined: 4 months ago
Posts: 534
 

That's a really important observation about reliability, and it's something we see a lot with teams trying to use these features for formal tracking. Your example with the specific IP range and Terraform is a perfect illustration of where conversational language can fail.

While the workarounds others mentioned can help, you've put your finger on the core issue: if a feature designed to 'remember' requires a specific syntax or a separate channel to function for critical data, it's not yet fit for that purpose. It's great for recalling broad themes, but for technical decisions like security rules, you're right to rely on your chat logs or a proper tracking system.

Have you found any other patterns besides IP changes that it tends to miss?


—HR


   
ReplyQuote
(@fionac)
Reputable Member
Joined: 4 months ago
Posts: 186
 

That's a frustrating example, especially with something as important as a security rule. I was hoping to use the memory feature for tracking our campaign decisions, like final copy approval for a landing page or setting a lead scoring threshold.

But your experience shows it might fail on the exact details we need to remember. It sounds like it's good for the 'what' but not the 'how' - remembering we decided to tighten security, but forgetting the IP range. That's a pretty big gap.

I'm curious, have you tried rephrasing the ask when you check the recap? Instead of "recap last week," something super specific like "what was the bastion host IP decision?" I wonder if that triggers a different search.



   
ReplyQuote
(@devops_grunt_2024)
Honorable Member
Joined: 8 months ago
Posts: 535
 

You're trying to use a chat feature as a source of truth. That's the mistake. Your chat logs *are* the system of record, and you should have a real one. A Jira ticket, a commit in your Terraform repo, an annotated changelog. Anything with an actual timestamp and version.

It forgot the IP range because it's not a database, it's a language model pattern matcher. They're unreliable for anything that requires precision. Treating them otherwise is just asking for an outage when someone implements the wrong CIDR block from a hallucinated "memory."


If it ain't broke, don't 'upgrade' it.


   
ReplyQuote
 dant
(@dant)
Honorable Member
Joined: 4 months ago
Posts: 434
 

Your workaround highlights the fundamental limitation: you've effectively built an imperative logging system on top of a probabilistic one. The dedicated channel with a strict command prefix is just a human-enforced schema for data ingestion.

This mirrors a classic pattern in distributed systems where you have an eventually consistent store - you can't rely on it for linearizable reads of critical state without a consensus protocol. Your "Add to memory:" command is a form of two-phase commit, forcing a write. The problem is that most teams won't maintain that discipline over time, especially under pressure.

What's your long-term plan when someone forgets the exact syntax or posts the command in the wrong channel? Do you have monitoring on that decision feed?



   
ReplyQuote
(@hannahr)
Reputable Member
Joined: 4 months ago
Posts: 285
 

You're right about the discipline problem. We tried that "imperative logging" approach for a few months after a bad data migration. It worked in theory, but like you said, under sprint pressure, people reverted to natural language. The syntax got fuzzy, and suddenly "Remember to update the S3 lifecycle policy" was in the memory, but not the actual policy ID.

Our long-term plan was to treat the memory strictly as a temporary notepad. Anything critical gets a forced migration out of chat within 24 hours - into a ticketing system's description field, a commit message, or a wiki update. The monitoring was manual, a painful checklist item for the meeting owner. It felt like adding a second, less reliable source of truth.


Data is sacred.


   
ReplyQuote
(@aidenh5)
Reputable Member
Joined: 4 months ago
Posts: 312
 

It's not ready. It's a pattern matcher, not a ledger.

We tried using it for deployment approval gates and had the same issue. It would remember "we approved the release" but lose the crucial version tag or environment name.

The trick that sometimes worked was a blunt force recap at the very end of the sync. Someone types: "SYNC MEMORY DUMP:" followed by bullet points of every decision verbatim. Even then, it was inconsistent. We stopped relying on it for anything that would cause a production issue.

Use your commit message in the Terraform repo. That's your real memory.


Ship fast, review slower


   
ReplyQuote
(@cloud_infra_vet)
Honorable Member
Joined: 5 months ago
Posts: 389
 

The "SYNC MEMORY DUMP:" approach is a fascinating, if grim, workaround. It effectively treats the feature as a CLI, where you're piping structured data into an unpredictable parser. We attempted a similar tactic by prefixing every critical data point with a key like `ENV_TAG::prod-1.4.2`. It helped retrieval but corrupted the conversation flow entirely.

Your deployment approval example is key because it reveals the feature's failure on compound data. Remembering an approval is a single boolean fact. Remembering the approval *plus* the version tag is a relational tuple. The system reliably drops the relational context, which is precisely what causes operational risk.

I've started calling this the "amnesia of association." It's why our team now enforces that any chat decision referencing an artifact must include the artifact's immutable URI, like a commit hash or ticket number, in the same message. The memory might recall the ticket number, which then points to the real system of record.



   
ReplyQuote
(@amandak9)
Reputable Member
Joined: 4 months ago
Posts: 209
 

Rephrasing the ask can definitely help a bit, I've found it pulls the specific fact from the noise. But that only works if the specific fact was actually recorded in the first place, and that's the real gamble.

Your campaign example is perfect. It might remember "we approved the landing page copy," but lose the specific version hash or the stakeholder who gave final sign-off. I've seen this with lead scoring thresholds, too - it recalls we *changed* the threshold, but the exact number gets fuzzy.

So you can treat it like a less-than-reliable search function. If you know exactly what you're looking for, and it was stated very clearly, asking directly might get it. But you can't trust it as a full record.


Show me the accuracy numbers.


   
ReplyQuote
(@finnj)
Reputable Member
Joined: 4 months ago
Posts: 269
 

>it's not yet fit for that purpose

That's the charitable read. The uncharitable one is that it's actively harmful because it creates the illusion of a reliable record. We've had it miss entire categories of technical details, not just IPs.

It regularly forgets which specific third-party service was approved for a new integration. It'll remember "we agreed to use a new analytics provider" but confidently swap out the actual name we decided on for a more common one. Same with API rate limits, retention periods for logs, and the names of external contractors.

You're absolutely right to call for a proper system. Using this for technical decisions is like trying to nail down a contract with a whiteboard marker.


FOSS advocate


   
ReplyQuote
(@consulting_contractor_mike)
Honorable Member
Joined: 8 months ago
Posts: 393
 

The "illusion of a reliable record" is the precise operational risk I've seen cause drift in two separate environments. It creates a false sense of safety that leads teams to skip proper documentation, under the assumption the chat has it.

Your example about the third-party service name being swapped is telling, and I've observed the same pattern. It doesn't just forget, it *confabulates* with a plausible alternative, which is far more dangerous than a blank. A team member will read "we agreed to use New Relic" with high confidence, when the actual decision was for Datadog, simply because New Relic is a more common referent in the training corpus.

This forces a cultural dependency on everyone remembering to distrust the memory, which is unsustainable. You're better off treating it as having no memory at all.


Mike


   
ReplyQuote
(@bluefox)
Reputable Member
Joined: 4 months ago
Posts: 228
 

Yep, that's the exact scenario that pushed us away from relying on it. It's great for remembering we *had* a meeting, but the technical specifics vanish.

We found it fails worst on compound details like your IP range and implementation method. It might recall "we changed a security rule" but the critical data gets lost. So it feels useful until you need the actual decision.

Our trick was to treat the memory as a trigger, not storage. Right after the meeting, we'd take the recap and paste it directly into a ticket or a wiki page. The memory was just a reminder to do the real documentation.



   
ReplyQuote
(@ellej)
Reputable Member
Joined: 4 months ago
Posts: 272
 

The "blunt force recap" is basically trying to brute-force a schema into a system that actively fights it. You've hit on the core issue: it's great at remembering an *event* ("we approved") but reliably fails at the *metadata* that makes that event useful (the version tag).

This is why we gave up on it for any technical decision-making. It creates more work because you now need a verification step to check what it actually retained. The Terraform commit message advice is spot on - it's an immutable, versioned record. The chat memory is just a post-it note on a windy day.



   
ReplyQuote
Page 1 / 2