Activity
Mon
Wed
Fri
Sun
Sep
Oct
Nov
Dec
Jan
Feb
Mar
Apr
May
Jun
Jul
Aug
What is this?
Less
More
Clief Notes

45.7k members • Free

AI Automation Society

440.3k members • Free

AI Automation Vault

30.7k members • Free

AI Automation Network

5.2k members • Free

43 contributions to Clief Notes
How do you stop an agent from trusting a fact that quietly went stale?
Most of my reference layer is facts the agent treats as true: this contact prefers X, that endpoint lives here, this rule still applies. the trouble isn't wrong facts, it's facts that were true when I wrote them and quietly went false. nothing errors, the agent just confidently uses a dead one. I've tried an expiry date per fact and a re-check pass at the start of a session, but expiry is mostly a guess and re-checking everything is slow. for anyone keeping a real knowledge layer and not just live workflow state: do you delete a stale fact, overwrite it, or keep it and mark it superseded so the old answer still explains a past decision? and how do you pick what's worth re-verifying versus what you just trust? curious what's actually held up for you.
0 likes • 17h
This is really helpful, thanks everyone. Justyn's point about only checking the facts a session actually touches is what unlocks it for me. The reason re-checking felt slow is that I was treating the whole reference layer as if all of it mattered every run, when most of it isn't load-bearing for the task in front of me. Made me think the real split isn't delete vs keep, it's what kind of fact it is. A plain lookup like "this endpoint lives here" can just get overwritten when it changes, nobody needs the old value. A fact a past decision leaned on is different, and that's where Leonard's archive-never-delete earns its place, since the stale value still explains why I did what I did back then. What I'm still chewing on: how do you even notice a lookup went stale, if nothing errors? TTL is a guess, and I don't want to re-verify things I never touch. Has anyone tied the re-check to the moment a fact is about to be used instead of to a clock?
Is anyone commercializing ICM as a Product or SaaS?
I am running an ICM knowledge base for my engineering company using GitHub, VS Code, and Claude Code. The efficiency gains in our workflows have been massive, and I see a clear opportunity to offer this to other regional companies as a new business unit. ​However, this dev-centric stack creates too much friction to be presented directly as a product to non-technical clients. ​The model I envision starts with heavy consulting to align the client's processes and culture. Once maturity is reached, it transitions into a managed service: issue tracking, periodic context pruning, and ad-hoc consulting for new agentic features. ​Has anyone here successfully commercialized this philosophy? I am particularly interested in how you package the delivery and abstract the technical friction (like the IDE and repo management) for the end user. Are there platforms already solving this?
2 likes • 3d
I run this across a group of companies that are all non-technical, so this one hits home. I've landed close to where you moved to, but with one shift: the variance everyone's naming (hand-holding, how much they've already written down) doesn't get absorbed, it gets fenced. what killed my margin early was letting clients edit the structure freely. give a non-technical team write access to the folders and drift comes right back, and every drift is a support call, so the "product" quietly rots into bespoke consulting again. so now they operate through a narrow interface that only reads and does constrained writes, and the structure has one owner: me, or honestly an automated janitor that flags stale files, dead links, anything that moved. that piece I can actually price, because it's bounded and repeats identically per client. the process-mapping and culture work stays on a consulting meter, never in a seat price. the cost nobody puts in the model is the one Mike named upthread: the demos and the re-explaining. that's not delivery, it's sales, and it's brutal. I'd carry it as CAC, not onboarding. for those further along on pricing, are you keeping structural write access after handoff, or handing it over and charging the re-cleanups as they come?
1 like • 2d
@Martin Brion building your own for control is the right instinct, but the tool matters less than where you put the write boundary, so I'd lock that down before the stack. clients should touch a thin surface (forms, approvals, a dashboard) and never the structure itself. they propose, the system writes. the moment a non-technical client can edit the folders directly, drift comes straight back, and every drift is a support call. that's the exact economics that sank Forestry. so build the smallest app that hides the dev stack for one workflow you already run well, ship it, and widen the surface only when a paying client pushes on it. building the general platform first just gold-plates seams nobody asked for yet. what's the one workflow your first client would pay for on day one?
Folders are great until state starts moving. what I pulled out (and what I kept)
I'm deep in ICM like everyone here and folders still carry most of my work. but I kept getting bitten by the same class of bug, and it wasn't a folder problem, it was a state problem: what's running, what's half-done, who owns the next move, what's safe to resume. that stuff changes by the hour, and a folder is a bad place to keep something that changes by the hour. so I stopped forcing it. the map stays in folders, the live state moved to rows. four things actually held. One writer. agents propose, exactly one process commits. the two-agents-edited-one-record mess disappears the day you stop letting every step write. Every touch gets a timestamp. not for audit theatre, for staleness. "is this stale" stops being a feeling and becomes a query: anything open and untouched for N days gets flagged. Done means the effect exists, not that the code reached the line. a step isn't allowed to mark itself done; something else confirms the artifact is really there first, or a clean run that produced nothing quietly poisons every retry after it. Folders still win for anything a human reads: context, knowledge, the map an agent walks. I didn't move that to a database and wouldn't. rows are only for the stuff that moves. what I'm still unsure about is when to make the jump. too early and you've built a database to hold six rows, too late and you're debugging drift at 2am. the real signal for me was the third time I couldn't answer "what state is this in right now" without opening five files. where do you draw that line? what made you move state out of folders, or what's kept you from it?
1 like • 2d
@Jim Tyndall the worse one for me: two sessions read the same state, both act, both write different files, so git never conflicts and both "succeed", but one of the two effects quietly isn't real anymore. nothing tangles, nothing errors. git can't see it because the bytes never overlap. what made it loud again was a version on the state row plus compare-and-swap on every write: if the rev moved since you read, you lost, and you hear about it at write time. are you seeing yours only at commit because git is still serializing you, or because nothing's truly concurrent yet?
1 like • 2d
@Carla Bosteder I don't teach it both. the folder is the only thing it opens cold, and one line in the root points at where live state lives plus the key to look it up by. it holds the address, not the rows. then a step reads a row only when it's about to act, by id, never as a preload. so the map stays in context and state gets pulled lazily, one row at a time, at the moment a step needs "what's running / who owns the next move." loading both up front is the thing that rots: you end up holding a snapshot that's already stale by the time you act on it.
How do you make a scheduled agent safe to re-run after it dies halfway?
I run a few agents on a schedule — ones that read some inputs and then do things with side effects: send a summary, write a record, flip a status somewhere. The happy path is fine. My worry is the failed run. The cron fires again, or I re-run it by hand, and now I'm nervous it'll redo the half it already finished: a second email, a duplicate record, a status changed twice. Today I lean on a checkpoint file. The run marks each side-effect done before moving on, and on restart it skips whatever's already marked. It works but feels brittle, since the mark and the action aren't atomic — a crash between them can still double-fire. How do you handle re-runs? Idempotency at the destination (dedupe keys, upserts)? A ledger the run reads first? Splitting read from write so the write step is the only thing that has to be safe? Curious what's actually held up for you in real unattended runs.
0 likes • 6d
@Aaron Kruger Separate, deliberately. Early on I kept it beside the run's own output and got bitten right there: the restart that wipes the workspace also wipes the record of what already finished, so the resume reads nothing and replays from zero. Now it lives in durable storage the crash and the pre-run cleanup can't reach, and the "done" mark lands there before I treat the side effect as real. Workspace stays disposable; the memory of what happened doesn't sit inside it. Do you key yours per run id or per logical step? That's usually where I see the two get colocated and the resume quietly lost.
0 likes • 3d
@Nicolas Patron Uriburu this is the one that actually scares me, because the checker is only as good as the postcondition you hand it. "artifact exists and has the right shape" still passes when the run writes a well-formed empty: the report file is there, headers and all, zero rows. shape-valid and meaningless. so I stopped tying done to presence and tied it to a count the effect can't fake: row landed, id came back, N > 0, then done. on the silence reading the same both ways, I made the missing success ping the alarm. the job has to emit "finished, produced N", and a watcher fires when that line never shows, so a clean finish and a quiet give-up stop looking identical. in your shape test, are you checking structure only, or something a no-op literally can't fabricate?
Grok Bots! 48 hours in. Deep dive coming.
I’ve been testing Grok Bot for 48 hours. Not a chat. A fleet. Hour 6 was chaos. Hour 46 was seats, recipes, and the quiet click of oh, this is a desk. I’m writing what actually happened. The deep dive, not the demo. Notes stay notes. If you’re already on Claude Code and you’ve been wondering what it feels like to stop prompting and start staffing, that’s the post. Full deep dive coming on: https://aris-space.com //A<3
Grok Bots! 48 hours in. Deep dive coming.
0 likes • 5d
what flipped it between hour 6 and 46? every fleet I've run had that same chaos phase, and the fix was always one boring rule rather than a redesign. curious which one it was for you.
1-10 of 43
Leo Saraiva
5
288 points to level up
@leo-saraiva-7733
Leo

Active 8h ago
Joined May 3, 2026
Portugal
Powered by