PrimeLine

Cognitive agent system that remembers and heals itself. Learns from its mistakes • knowledge graphs • bio-inspired routing • 15K nodes • open source - Da Nang

[PrimeLine @PrimeLineAI]

https://t.co/F9T2KRb6MU

[PrimeLine @PrimeLineAI]

the tell for me was the asymmetry. my security hooks are a real harness, they reject the command and exit. my completion gates are markdown asking the model to remember a rule. 574 stop-gate events, zero blocks, and 0 of them carried the evidence markers the gate looks for. same repo, two enforcement levels.

[PrimeLine @PrimeLineAI]

@rahulbais136 You only post something like that if you have absolutely no idea about AI.

[PrimeLine @PrimeLineAI]

Strong pipeline. Two things from a planning framework I use that would slot in cleanly:

1. Force a FAILED condition with measurable threshold + timeout into every exam sheet. Without it the night shift can keep iterating on a zombie task.

2. Add an explicit AHA/existing-work check inside the interviewer (before the brief is written). Catches the “90 % of this already exists” cases that otherwise only surface after the work order is signed.

The rest of your loop (fresh inspector + narrated proof + owner’s manual) is already stronger than most planning systems. Happy to share the exact anti-pattern list / FAILED format if useful.

[PrimeLine @PrimeLineAI]

@LucaCaponeX @jasonzhou1993 Depending on the rule, you can create hooks that are a hard enforcer, instead of something where the agent can decide or ignore it.

[PrimeLine @PrimeLineAI]

@MichLieben I've been working on this for months, and I'm currently stuck at the logging/analysis stage. So many different little settings need adjusting, and sometimes you only notice something's wrong after days of operation.

[PrimeLine @PrimeLineAI]

@ojigineko_tips That's about as smart as trying to think only like Einstein and thereby obscuring your own way of thinking. You won't become Einstein, and you yourself won't be as effective as before.

[PrimeLine @PrimeLineAI]

@PawelHuryn Did you run the test in a sandbox environment or with an existing system, including hooks, skills, etc.? Thanks for sharing.

[PrimeLine @PrimeLineAI]

my coding agent already had "prove it worked," "diff before you delete," "check deps before you change."

the rule it was missing: build on a copy and stress-test before it goes live.

found that out when it almost trimmed my live config on an untested change. the gap was invisible till it nearly bit me.

>_

[PrimeLine @PrimeLineAI]

@kyroxxxq That's a good concept for knowing what you maintain and access. But it's not designed for agentic work. As you said, if you just throw something in there, it all clumps together.

[PrimeLine @PrimeLineAI]

You cut Fable down to the orchestrator. The real cut is out of it.

The orchestrator is the one seat that fires on every turn, so it's the most repeated cost in the session. Narrowing its job to planning doesn't change that it's still the frontier model in the priciest chair. To actually cut cost you take Fable out of that chair, not down to it.

Put a cheap model in the hub, let it plan (or delegate is to Fable to plna) and route, and call Fable on-demand only for the judgment that earns the rate. You already draw Opus and Sonnet as dispatched-on-demand workers. Same logic one level up: make Fable a worker you call, not the thing running every turn.

That's the gap between "cheaper than Fable-for-everything" and actually cheap. I A/B'd Opus 4.8 against Sonnet 5 in the orchestrator seat on the same long-horizon tasks and it came out even, so if stepping up from Sonnet to Opus buys nothing in that chair, putting Fable there is even harder to justify. A cheap hub plus on-demand escalation then holds up at a fraction of the cost, as long as the routing layer underneath is real.

[PrimeLine @PrimeLineAI]

"The smartest model runs the show" is the right move when nothing else is making the routing call. No system to decide where work goes, so you buy that decision in the model.

Build the routing layer and the expensive model doesn't need the driver's seat. I run Sonnet in the session, score each task against an adaptive threshold, cheap lanes for the volume, Opus/Fable escalated on-demand for the calls that earn it. Same lanes you drew, just not paying top tier to hold the wheel.

Because the cost isn't the typing, it's the seat. The orchestrator fires on every turn, so it's the most repeated cost in the run, and the one you least want on the top rate. On-demand pays it only when it's earned.

Honest read from my own runs: proven cost gap, no sign of a quality gap. The tier premium mostly pays for judgment a routing layer already handles. Most people just haven't built the layer, which is exactly why it feels like the smart model has to sit on top.

[PrimeLine @PrimeLineAI]

I run Sonnet 5 as the orchestrator. Switched to it on purpose after having Opus in that seat.

Not because Sonnet got better or Opus got worse. For the orchestrator role they came out on par in my own testing. The win is tokens: that seat fires on every turn, so it's the single most repeated cost in the system. Same executor-rate logic as the quote, just aimed at the most expensive seat instead of the leaf calls.

But it's not a naked model-swap. What carries it is the layer underneath every dispatch:

› Score-based delegation. Each task gets scored (scope, exploration, bulk, risk keywords) against an adaptive threshold that shifts with context load, recent success rate, and how many agents are already live.

› A model-tier matrix. Complexity bands route the work: cheap tier for bulk, Sonnet for the middle, Opus escalated on-demand only for the genuinely hard calls. Fable-as-advisor is a clean version of that same escalation.

› Outcome auditing. Every dispatch logs its result, and the recent success rate feeds straight back into the threshold, so routing adapts instead of following a frozen rule.

› Coordination state. Agents register intent and scope before dispatch, so parallel workers see each other and don't collide on the same domain.

Strip that layer and yeah, Sonnet-as-orchestrator falls over. With it, the base model can be the cheap one and the expensive model becomes a tool the orchestrator calls, not the thing running the whole loop.

[PrimeLine @PrimeLineAI]

i love those projects. the thing that decides if it's actually jarvis or just a fancy prompt is memory across sessions. does yours read and write the vault so it remembers what you told it yesterday, or does every run start cold? that persistence layer is the piece i kept rebuilding until i broke it out: https://t.co/AW92fs2sj5

[PrimeLine @PrimeLineAI]

the 3x-catch is the fun part, but flagging a dupe is the easy half. once the loop finds three versions of one idea, which one wins? auto-merge and it quietly rewrites your vault wrong, leave them and the pile just grows. does yours resolve that or stop at flagging? what worked for me was tagging supersede/conflict explicitly instead of trusting similarity: https://t.co/AW92fs2sj5

[PrimeLine @PrimeLineAI]

once agents edit the memory every run, a wrong inference on run 5 is ground truth by run 50. compounding context compounds the mistakes too, not just the wins. do you separate what the agent inferred from what you actually confirmed, or does it all read back as fact? provenance was the piece i had to build in for exactly that: https://t.co/AW92fs2sj5

[PrimeLine @PrimeLineAI]

answering your P.S.: compounding was never my problem, forgetting was. a wiki that only accretes ends up holding three versions of a fact and confidently serving the oldest. what fixed it for me was decay + a supersede signal, so a corrected note actually retires the one it replaces. did OKF handle staleness for you, or is that still on the reader to catch? open-sourced the memory engine i built for it: https://t.co/AW92fs2sj5

[PrimeLine @PrimeLineAI]

v0.2.0 also fixes a real bug: any process embedding Kairn used to hang on shutdown (leaked thread on exit). That's fixed now, plus 4 new tools and namespace isolation.

pip install kairn-ai
https://t.co/24AJOi8Frw

[PrimeLine @PrimeLineAI]

Shipped v0.2.0 of Kairn, my open source memory engine for AI agents (MIT, pip install kairn-ai).

most memory tools store flat key-value pairs. Kairn builds an actual knowledge graph with typed relationships, plus a context router that loads only what's relevant instead of dumping everything into the prompt.

[PrimeLine @PrimeLineAI]

Where it's not there yet: cross-session synthesis (41.4%) and one-shot preference questions (10%). Published both, right in the README next to the good numbers. Every release touching recall re-publishes the full table until those move.