u/mercurias98

I started building products and then i shifted into building systems. Then those very systems started changing how i think.

I dont have a technical co-founder, engineering team. i started out with a problem.

Over the past few months i built Aevron, a multi-agent AI cognitive infrastructure system. i have currently have 50+ users. Then i built a end to end automated trading system and then i built Whozin, a group decision platform. It is still under development. Building all these have made me learn things i would not have otherwise be able to learn.

Turning vague intent into working architecture

Every single product starts with basic. "I want thinking to connect and evolve.", "I want stocks to be analysed automatically." The real work begins with questions like what data does this need, what should the system remember, what triggers what, what happens when something fails? You learn to translate intent → logic → architecture → behaviour. That translation is the actual skill and reading about product development never forces you to do it.

Converting human judgment into decision logic

Everyone says basic things or vague idea but systems need something precise. The trading setup made this unavoidable, intuition needed to become signals, conditions, rules, decisions. Most people who say they understand markets cannot do this translation. I needed to this. That gap between what you know and what you can actually encode is very important and needs to be precise.

Thinking in state, not just inputs and outputs

The biggest shift is when, useful systems are not stateless. History and context matters more than we think. What the system already knows matters. What has gone stale matters. Aevron deals with continuity of thought. Whozin deals with evolving group preferences. The trading system deals with changing market conditions. Three completely different products but built with the same underlying principle. The present only makes sense when the system understands what came before it.

Designing coordination between parts

Once a system becomes complex, intelligence becomes distributed. One component retrieves. Another analyses. Another validates. Another decides what happens next. Sometimes a human enters the loop. That forces thinking about ownership, handoffs, dependencies, sequencing, failure points, recovery. This kind of thinking only becomes obvious after something actually breaks and costs you something.

Knowing where AI should and should not make decisions

Not everything should be probabilistic and needs to be automated. Some problems need reasoning. Some need hard rules. Some need human judgment. The real skill is not to use AI but it is defining the boundary between AI judgment, deterministic logic, and human control.

Debugging systems instead of symptoms

When an output is wrong, the failure is usually upstream, bad data, wrong context, broken handoff, a weak assumption, or several of these interacting at once. Building taught me to trace failures backwards through the system instead of fixing whatever looks broken on the surface. I developed a habit of making a corrective action plan for all the possible failure modes so even the failures happen, the systems already have a plan.

Becoming precise about intent

The larger a system becomes, the more expensive ambiguity gets. "Make this smarter" means nothing. You need to know what exactly should happen, under what conditions, what should never happen, what does success actually look like. That precision has changed how I think about problems more than anything else, inside and outside product work.

I built everything on the basis of context and connectivity. The system becomes intelligent when it understands not just what something is but what came before it, what surrounds it, what it connects to, and what should happen next.

Anyone else gone through something similar building solo? Curious what skills surprised you most.

Both Notion, Obsidian, Roam, etc are good tools but have major flaw and that is everything depends on you. Now some people live to do everything on their own but on majority of the cases these become graveyard of notes, projects, folders, files, etc unless and until you do everything all the time.

For example, Notion gives you a lot of pages, folders, organisers, tags, etc but they quickly die down because you are required to maintain everything time to time.

And with Obsidian, you can connect things manually, Links, Backlinks, Graphs, MOCs, Plugins and if you dont maintain these constantly, they die down just like how Notion became a graveyard. Now Obsidian can be used using claude code and plug ins but it requires serious work and it has it's own limitations and it still requires you to be the one doing things.

But on the other hand, Aevron flips the entire structure. Aevron is not just a knowledge management tool or note taking tool. It is essentially and thinking infrastructure. Capturing a thought is just one half and it was already solved but what happens after you capture a thought is what matters more and whats the impact on your thought process matters more.

Aevron focuses not only on the capture, organising, managing, maintaining but it puts more focus on the latter part.

So instead of:

Capture → organize → remember → search → connect → develop

the goal is closer to:

Capture → understand → connect → resurface → develop

automatically.

You capture something and then it gets connected to all the previous ideas automatically, resurfaces things you forgot, finds contradictions and hidden insights within your thought process, finds and analysis recurring patterns within your thought process, develops your notes, ideas, thoughts further using the pre existing context and then it keeps the thought continuity alive.

Now How is this possible because Aevron creates something called thinker model and thought evolution. Basically, Aevron understand and analysis your behaviour signals, linguistic signals and thought evolution signals by hat you capture, how you capture, what sessions you have inside Aevron and this further becomes a context for Aevron to understand and helps you evolve your thinking.

My aim with Aevron is to not create any other tool that lets you capture things and search for you but to create a system where you actually get smarter day by day using your own thinking as a powerhouse. So Aevron is not just a tool but a system.

I am still a one person team and Aevron is still in beta testing phase with over 50+ users and i am very optimistic on how this turns out. it is still completely free to use and I would love if you guys join in as beta testers or actual users. I would love to discuss if you guys have any questions, perspective and better ideas. As a one person building this, i could use some users option and feedback.

Both Notion, Obsidian, Roam, etc are good tools but have major flaw and that is everything depends on you. Now some people live to do everything on their own but on majority of the cases these become graveyard of notes, projects, folders, files, etc unless and until you do everything all the time.

For example, Notion gives you a lot of pages, folders, organisers, tags, etc but they quickly die down because you are required to maintain everything time to time.

And with Obsidian, you can connect things manually, Links, Backlinks, Graphs, MOCs, Plugins and if you dont maintain these constantly, they die down just like how Notion became a graveyard. Now Obsidian can be used using claude code and plug ins but it requires serious work and it has it's own limitations and it still requires you to be the one doing things.

But on the other hand, Aevron flips the entire structure. Aevron is not just a knowledge management tool or note taking tool. It is essentially and thinking infrastructure. Capturing a thought is just one half and it was already solved but what happens after you capture a thought is what matters more and whats the impact on your thought process matters more.

Aevron focuses not only on the capture, organising, managing, maintaining but it puts more focus on the latter part.

So instead of:

Capture → organize → remember → search → connect → develop

the goal is closer to:

Capture → understand → connect → resurface → develop

automatically.

You capture something and then it gets connected to all the previous ideas automatically, resurfaces things you forgot, finds contradictions and hidden insights within your thought process, finds and analysis recurring patterns within your thought process, develops your notes, ideas, thoughts further using the pre existing context and then it keeps the thought continuity alive.

Now How is this possible because Aevron creates something called thinker model and thought evolution. Basically, Aevron understand and analysis your behaviour signals, linguistic signals and thought evolution signals by hat you capture, how you capture, what sessions you have inside Aevron and this further becomes a context for Aevron to understand and helps you evolve your thinking.

My aim with Aevron is to not create any other tool that lets you capture things and search for you but to create a system where you actually get smarter day by day using your own thinking as a powerhouse. So Aevron is not just a tool but a system.

I am still a one person team and Aevron is still in beta testing phase with over 50+ users and i am very optimistic on how this turns out. it is still completely free to use and I would love if you guys join in as beta testers or actual users. I would love to discuss if you guys have any questions, perspective and better ideas. As a one person building this, i could use some users option and feedback.

I have been building a tool called Aevron and it is right at the intersection of PKM tools and AI tools. It it is very different from the PKM category tools, but it is also very different from AI tools in terms of approach.

So what is Aevron?

You capture a thought. Aevron connects it to everything else you have ever captured, finds what contradicts it, and develops it into something you can actually use. No prompting. No organising. Just thinking that compounds.

The main objective is thought continuity and evolution on individual level and institutional level.

I have been thinking about how this changes the approach to education using Aevron. So here is what i have designed and i think this is a very different outlook at education.

Our education system has one flaw and that is we are too focused on assignments, exams, quantitative output that out thinking disappears very frequently. the knowledge students gain gets lost every now and then, teachers not able to effectively plan out their session and they go back to old way of teaching. Researchers losing track of their observations and validations because there is too much to comprehend.

So thought continuity and knowledge continuity is what Aevron solves. The preservation and development of a thinker's thinking across time.

So here is the breakdown -

For students - Education is a whole, meaning, intellectual, emotional, social, physical. But no tool has ever given children a way to track what they're thinking across time, not as a performance for teachers, but as a record for themselves.

Aevron at K-12 is a metacognitive scaffolding layer. A child captures a question, connects it to something they noticed last month, returns to it. That's not a feature. That's the first experience of taking your own thinking seriously.

Every AI tool in higher education has optimised for the wrong thing: faster generation, quicker answers, content on demand. That's cognitive offloading. It substitutes for thinking rather than developing it.

Aevron is built for the opposite mod, what researchers call co-constructed metacognition. The student isn't asking Aevron to write their essay. They're asking it to remember what they thought about the argument last Tuesday, surface the connection to something captured two months ago, show them how their position has evolved.

The semantic distinction matters: sense-making versus answer acquisition. Every other tool is optimised for the second. Aevron is built for the first.

Now for Researchers, it gets interesting because a research or PHD is a long spam project and it usually deals with a lot of fragmented ideas, knowledge and thoughts. Aevron fills the gap, not as a search engine over papers, not as a citation manager, but as the persistent graph of this researcher's thinking as it develops across years. Every idea captured. Every connection surfaced. Every position shift tracked.

Now why does Aevron has an upper had over other PKM tools and Ai tools in this scenario is because -

1. The knowledge graph is persistent and autonomous - Every capture gets connected to everything else. The connection exists whether the student remembered to make it or not. The PhD's discarded framework from eighteen months ago gets surfaced when a new idea makes it relevant again. No other tool does this.

2. The thinker model - Aevron builds a cognitive map of each user over time reasoning style, active frontiers, core resistances, positions that are shifting, territory that keeps going quiet. This is what makes the output personal rather than generic. It is also what makes the educator-facing signal possible.

3. Cross-time reasoning - Aevron can tell a student how their thinking on a topic has evolved since they first captured it. Thought continuity and it requires a persistent graph, a thinker model, contradiction detection and synthesis across time.

Every other tool remembers what you wrote. Aevron remembers how you think — and keeps working on it after you leave.

I want to develop this design even further and collaborate with real students, teachers and researcher. So if you resonate with this then i want to experiment this and see how impactful this is.

Ok so I've tried basically every tool. Notion, Obsidian, Roam, whatever AI thing was blowing up that month.

here's what's actually going on.

thinking happens in fragments

the insight you're looking for isn't missing. it exists. it's just scattered across three different things you captured at completely different times without realising they were even related. one note from six months ago. a half finished thought from last week. something you said out loud that you never actually wrote down. the real insight is in the connection between all of them, not in any single one. your tool saved each one separately and called that organised. it's not.

thinking has never happened in one clean note and it never will.

the tool does literally nothing while you're away

you captured the thought. that's the hard part. that's the actual moment of real thinking happening. and then the tool just... sat there. waiting for you to come back, open it, scroll through everything, and do all the connecting yourself. the tool didn't work. you worked. the tool just held your stuff still until you showed up again.

every tool treats capture like the finish line. it's not even close to the finish line.

AI remembers the conversation. not how your thinking actually changed.

there's a real difference between remembering what you said and tracking how an idea you had three months ago quietly became something you now believe in a completely different way. one is just a transcript. the other is actually understanding how your mind moves.

every AI chat tool does the first one. none of them notice that the argument you were confidently making in March is now the exact thing you're arguing against, and that the shift happened slowly across a bunch of separate sessions, and is now basically the foundation of everything you're working on.

that gap between what you said and how you've changed is where most of your real thinking lives. it's also the thing every tool you're using right now is quietly throwing away.

it accumulates. it doesn't compound.

more notes is not more thinking. it's just a bigger pile. there's a difference between accumulating stuff and actually compounding it and every tool treats those like the same thing. compounding means one idea builds on another, which means something has to hold both in relation to each other over time, which means something has to be doing that work in the background when you're not there.

the notes app isn't doing that. the second brain isn't doing that. the AI chat resets every single session. so you keep adding, the pile keeps growing, and the pile never becomes anything other than a pile.

you lose the thread of how your thinking evolved

not the notes. the progression. how one thought actually challenged the next one. how something you believed pretty confidently six months ago quietly became something you now see completely differently, and why that even happened.

that movement is honestly the most valuable thing your thinking has ever produced. more valuable than any single note or output or idea. and it's the one thing every tool you've ever used throws away by design. the tool saves the thought. it doesn't save the thinking.

the tools aren't failing because they're bad tools. they're failing because they were built for storage and not for how thinking actually works. storage is a solved problem. the other thing genuinely isn't.

Ok so I've tried basically every tool. Notion, Obsidian, Roam, whatever AI thing was blowing up that month.

here's what's actually going on.

thinking happens in fragments

the insight you're looking for isn't missing. it exists. it's just scattered across three different things you captured at completely different times without realising they were even related. one note from six months ago. a half finished thought from last week. something you said out loud that you never actually wrote down. the real insight is in the connection between all of them, not in any single one. your tool saved each one separately and called that organised. it's not.

thinking has never happened in one clean note and it never will.

the tool does literally nothing while you're away

you captured the thought. that's the hard part. that's the actual moment of real thinking happening. and then the tool just... sat there. waiting for you to come back, open it, scroll through everything, and do all the connecting yourself. the tool didn't work. you worked. the tool just held your stuff still until you showed up again.

every tool treats capture like the finish line. it's not even close to the finish line.

AI remembers the conversation. not how your thinking actually changed.

there's a real difference between remembering what you said and tracking how an idea you had three months ago quietly became something you now believe in a completely different way. one is just a transcript. the other is actually understanding how your mind moves.

every AI chat tool does the first one. none of them notice that the argument you were confidently making in March is now the exact thing you're arguing against, and that the shift happened slowly across a bunch of separate sessions, and is now basically the foundation of everything you're working on.

that gap between what you said and how you've changed is where most of your real thinking lives. it's also the thing every tool you're using right now is quietly throwing away.

it accumulates. it doesn't compound.

more notes is not more thinking. it's just a bigger pile. there's a difference between accumulating stuff and actually compounding it and every tool treats those like the same thing. compounding means one idea builds on another, which means something has to hold both in relation to each other over time, which means something has to be doing that work in the background when you're not there.

the notes app isn't doing that. the second brain isn't doing that. the AI chat resets every single session. so you keep adding, the pile keeps growing, and the pile never becomes anything other than a pile.

you lose the thread of how your thinking evolved

not the notes. the progression. how one thought actually challenged the next one. how something you believed pretty confidently six months ago quietly became something you now see completely differently, and why that even happened.

that movement is honestly the most valuable thing your thinking has ever produced. more valuable than any single note or output or idea. and it's the one thing every tool you've ever used throws away by design. the tool saves the thought. it doesn't save the thinking.

the tools aren't failing because they're bad tools. they're failing because they were built for storage and not for how thinking actually works. storage is a solved problem. the other thing genuinely isn't.

Threads did not start because I wanted better project organisation. It started because Aevron was being annoying about something.

Aevron flags contradictions between things you have previously thought. Which is actually useful. Except I kept seeing it flag stuff that was not really a contradiction. More like, my thinking had just moved on.

For example -

Thought 1: Build for Substack writers first. They publish on a schedule, they feel the pain acutely and they will tell you straight up if the output is trash.

Then a few day later, after actually talking to people:

Thought 2: Okay writers are not the only ones with this problem. Founders hit the same wall. Researchers hit it. Basically anyone who thinks for a living hits it. Why are we locking ourselves into one persona this early.

Aevron saw that as a contradiction. But it was not. I just learned something and updated. That is how thinking works.

The problem is if the system cannot tell the difference between you contradicting yourself and you just getting smarter, it becomes this thing that constantly tells you that you disagree with your past self without having any clue why your thinking changed. Not useful.

So I started thinking about how to actually track that progression. One thought leads somewhere. That somewhere gets challenged. Then refined. Then randomly three weeks later it connects to something completely unrelated and suddenly there is something new sitting there. Not isolated notes. A thread that has been running the whole time without you naming it.

That is where Threads came from.

Then I noticed something bigger. If Aevron can spot the thread, figure out which thoughts belong to it, track how it shifts over time and keep it alive, it is basically doing project management. Except I never made a project. Never named it. Never dragged anything into a folder. The structure just showed up from the thinking itself.

Projects are containers you build around work. Threads are patterns the system finds inside your thinking.

Knowledge tools should not just store what you thought. They should get how one thought turned into the next one

check out Aevron at www.aevron.co

Threads did not start because I wanted better project organisation. It started because Aevron was being annoying about something.

Aevron flags contradictions between things you have previously thought. Which is actually useful. Except I kept seeing it flag stuff that was not really a contradiction. More like, my thinking had just moved on.

For example -

Thought 1: Build for Substack writers first. They publish on a schedule, they feel the pain acutely and they will tell you straight up if the output is trash.

Then a few day later, after actually talking to people:

Thought 2: Okay writers are not the only ones with this problem. Founders hit the same wall. Researchers hit it. Basically anyone who thinks for a living hits it. Why are we locking ourselves into one persona this early.

Aevron saw that as a contradiction. But it was not. I just learned something and updated. That is how thinking works.

The problem is if the system cannot tell the difference between you contradicting yourself and you just getting smarter, it becomes this thing that constantly tells you that you disagree with your past self without having any clue why your thinking changed. Not useful.

So I started thinking about how to actually track that progression. One thought leads somewhere. That somewhere gets challenged. Then refined. Then randomly three weeks later it connects to something completely unrelated and suddenly there is something new sitting there. Not isolated notes. A thread that has been running the whole time without you naming it.

That is where Threads came from.

Then I noticed something bigger. If Aevron can spot the thread, figure out which thoughts belong to it, track how it shifts over time and keep it alive, it is basically doing project management. Except I never made a project. Never named it. Never dragged anything into a folder. The structure just showed up from the thinking itself.

Projects are containers you build around work. Threads are patterns the system finds inside your thinking.

Knowledge tools should not just store what you thought. They should get how one thought turned into the next one

We just added memory import to Aevron from ChatGPT, Claude, .md files and plain text and the obvious way to build this was:

upload everything → save everything → congrats, “personalised AI”.

This is okay but wont work that well. Because your ChatGPT history is not actually you.

It’s you + the AI + random ideas + stuff you changed your mind about 10 minutes later + context that probably means nothing now. If we dumped all of that straight into Aevron, it wouldn’t be learning how you think. It would just be learning your chat logs.

So we did it differently.

Aevron removes the AI replies first and only looks at what you wrote. Then it tries to find the actual signal:

- stuff you keep coming back to
- ideas you were genuinely developing
- patterns in how you think
- thoughts that are probably worth keeping

But even then, we don’t just shove everything into your graph You see it first. Approve what feels like you. Skip what doesn’t.

Then it becomes part of Aevron. The reason is pretty simple:

Bad memory gets worse over time.

If an AI wrongly thinks you believe something, that can mess with future connections, contradictions, suggestions and basically everything downstream.

So we ended up with this rule:

better to know less about you correctly than know everything about you badly.

The cool part is you also don’t have to start from zero anymore.

If you’ve spent 2 years yapping to ChatGPT, Claude or dumping thoughts into markdown files, you can bring that history with you without importing all the garbage around it.

So yeah, technically this is a memory import feature. But I think the more interesting way to describe it is:

we’re not importing your AI history. we’re trying to reconstruct your thinking from it.

We've been designing a different model for project management and I want to get the community's reaction, especially the objections.

The premise:

Every PM tool I've used starts from the same assumption: you know what you're working on before you start. Open Linear, create the project, assign tasks, update statuses. The tool is a container. You fill it.

The problem is that real work doesn't accumulate that way. At least not for me. Ideas build up. Connections form. Something becomes project-shaped over time, not because I decided it was, but because enough coherence accumulated that it earned the label.

So we've been building around a different model: threads that replace projects.

Not folder-and-task threads. Living semantic objects that the system maintains, rather than containers you manually manage. The project is discovered, not designed.

What this looks like concretely:

Individual level: you capture thoughts, observations, reflections as they arrive. No taxonomy, no upfront categorization. The system (Aevron, what we're building) watches the connections form, detects when a cluster of captures has become project-shaped, and surfaces it: this looks like a project, do you want to treat it that way? You opt in. Or you don't, and keep exploring. Either is fine.

We've been running this against real use cases. A stock analyst capturing five signal types over six weeks, never created a "project," but the thread developed more analytical structure than any manual folder would have produced. The system surfaced the tensions (strong fundamentals, questionable management decisions) and flagged the conflict rather than averaging it away.

That's what emergent project detection looks like in practice.

Team level, where it gets interesting:

Individual accounts stay private and sovereign. Each person captures in their own thinking environment. The system watches behavioral patterns across accounts, whose captures are clustering around the same domain, whose ideas others are building on, and surfaces merge candidates: these two threads are converging, do you want to connect them?

Ownership isn't declared upfront. It emerges from activity. When a human wants to override the system's suggestion, they can. But the default is the system infers, the human confirms or corrects.

Enterprise level:

A federated read layer sits on top of individual accounts. It doesn't write back into them, individual cognitive environments stay intact. What it surfaces:

• Which threads across the org are converging on the same domain without coordination (invisible silos, visible early)
• Whose activity patterns show emergent ownership before anyone declared it
• What stopped compounding, thread activity drops are often the earliest signal of a blocked project, weeks before a status field gets updated

The key claim: traditional PM tools show you what's active. This model shows you what's compounding and what stopped.

The objections I'm expecting:

1. Emergent detection is too slow. Fast-moving teams need declared structure on day one, they can't wait for coherence to accumulate.
2. The system will get ownership wrong. Behavioral inference from captures isn't the same as actual ownership, the person writing most isn't always the person responsible.
3. Enterprise buyers won't trust a bottom-up model. They want the org chart, not an inference engine.

I think objection 1 is real and the mitigation is that declaration remains available, you can always manually declare a project without waiting for emergent detection. Objections 2 and 3 I'm less sure about.

What's the strongest case against the emergent detection model that I haven't named here?

We've been designing a different model for project management and I want to get the community's reaction, especially the objections.

The premise:

Every PM tool I've used starts from the same assumption: you know what you're working on before you start. Open Linear, create the project, assign tasks, update statuses. The tool is a container. You fill it.

The problem is that real work doesn't accumulate that way. At least not for me. Ideas build up. Connections form. Something becomes project-shaped over time, not because I decided it was, but because enough coherence accumulated that it earned the label.

So we've been building around a different model: threads that replace projects.

Not folder-and-task threads. Living semantic objects that the system maintains, rather than containers you manually manage. The project is discovered, not designed.

What this looks like concretely:

Individual level: you capture thoughts, observations, reflections as they arrive. No taxonomy, no upfront categorization. The system (Aevron, what we're building) watches the connections form, detects when a cluster of captures has become project-shaped, and surfaces it: this looks like a project, do you want to treat it that way? You opt in. Or you don't, and keep exploring. Either is fine.

We've been running this against real use cases. A stock analyst capturing five signal types over six weeks, never created a "project," but the thread developed more analytical structure than any manual folder would have produced. The system surfaced the tensions (strong fundamentals, questionable management decisions) and flagged the conflict rather than averaging it away.

That's what emergent project detection looks like in practice.

Team level, where it gets interesting:

Individual accounts stay private and sovereign. Each person captures in their own thinking environment. The system watches behavioral patterns across accounts, whose captures are clustering around the same domain, whose ideas others are building on, and surfaces merge candidates: these two threads are converging, do you want to connect them?

Ownership isn't declared upfront. It emerges from activity. When a human wants to override the system's suggestion, they can. But the default is the system infers, the human confirms or corrects.

Enterprise level:

A federated read layer sits on top of individual accounts. It doesn't write back into them, individual cognitive environments stay intact. What it surfaces:

• Which threads across the org are converging on the same domain without coordination (invisible silos, visible early)
• Whose activity patterns show emergent ownership before anyone declared it
• What stopped compounding, thread activity drops are often the earliest signal of a blocked project, weeks before a status field gets updated

The key claim: traditional PM tools show you what's active. This model shows you what's compounding and what stopped.

The objections I'm expecting:

1. Emergent detection is too slow. Fast-moving teams need declared structure on day one, they can't wait for coherence to accumulate.
2. The system will get ownership wrong. Behavioral inference from captures isn't the same as actual ownership, the person writing most isn't always the person responsible.
3. Enterprise buyers won't trust a bottom-up model. They want the org chart, not an inference engine.

I think objection 1 is real and the mitigation is that declaration remains available, you can always manually declare a project without waiting for emergent detection. Objections 2 and 3 I'm less sure about.

What's the strongest case against the emergent detection model that I haven't named here?

We've been building a tool that treats HR decisions as an information problem, not a process problem. Here's what we learned and the tension we haven't fully resolved.

The premise:

Most HR decisions are made on bad information. Not bad intent. Bad information.

Annual reviews are driven by what a manager remembers which is mostly the last 90 days. Priya has been doing the work for 18 months. Months 1-15 are invisible. That's not a manager failure. That's a system failure. And no tool in the current HR stack fixes it because they're all built on the same broken foundation: point-in-time evaluation.

We built Aevron as a cognitive operating system, a tool where people log thoughts, project reflections, training insights, feedback, blockers. The kind of thinking that never makes it into a performance review because it's too raw, too in-progress, too hard to translate into a rating scale.

The architecture we landed on:

Every employee gets a private account. Private means private, raw logs never travel upward. Between the employee's account and everything above it sits a synthesis layer that extracts signal (patterns, growth trajectories, friction clusters, idea density) and sends that upward instead of the underlying content.

Synthesis parameters are set at the org level by admins. Three levers:

• Abstraction depth — how much does the synthesis abstract before signal travels up? At the highest level, HR sees "this employee is developing systems thinking." At the lowest, "this employee has flagged the same cross-team dependency three times this month." No direct content, ever.
• Signal cadence — weekly for managers, monthly for HR, real-time for critical flags
• Explorer scope — which questions HR is actually allowed to ask the system. Admins define the boundary.

Employees can see which abstraction level their org has selected. Not the full parameters, just the level. The logic being: you should know how abstracted your signal is before it reaches your manager, even if you don't control it.

Three scenarios where this changes the actual decision:

Promotion readiness: HR asks for an 18-month thinking trajectory instead of a manager's advocacy at annual review. What comes back: problem framing complexity over time, whether this person's ideas are building on by others, how they've responded to feedback, where they're stuck repeatedly. The decision is now a document, not a political argument.

Training vs. role change: Someone is underperforming. Default HR answer is more training. Aevron separates skill gap (high engagement, missing capability) from fit gap (high thinking quality in the wrong domain) from motivation gap (low idea density, mechanical outputs). These require completely different responses. Traditional HR conflates them constantly and then wonders why training spend doesn't move performance.

Manager quality: This is the one nobody can answer well. Vikram's team ships on time. That's the only data most HR stacks have. What Aevron surfaces instead: does the team generate more ideas together than individually, or is the manager creating dependency? Does reflection quality in the team drop during high-pressure periods — which would suggest the management style suppresses thinking under load? Are early attrition signals showing up before anyone has handed in a notice? The difference between intervening in month 4 and reading an exit interview in month 12 is significant.

The tension we haven't fully resolved:

If employees know their logs feed HR decisions, they'll curate them. Performance theater instead of honest thinking. Signal degrades into managed narrative.

Our architectural answer is that the private account isn't a trust promise, it's a structural guarantee, raw logs physically don't travel upward, so there's nothing to game. The synthesis layer is the only pathway.

But here's what's still open: synthesis transparency. Employees know their org has set an abstraction level, but they don't know exactly what patterns the synthesis is extracting or how sensitive the signal thresholds are. That's a real gap between "your content is private" and "your thinking is fully legible to HR via abstraction."

We've resolved it one way (show the abstraction level, not the parameters), but I'm genuinely not sure that's the right call. The counterargument is that even knowing the abstraction level tells you enough to optimise against it. A smart employee at Level 2 knows that "pattern-level" signal is being extracted, and can adjust accordingly.

The harder version of the problem: is there any amount of architectural privacy that survives the fact that the employee knows a system is watching? Or does awareness of observation always change behaviour, regardless of what the system actually sees?

I don't have a clean answer to that. Would genuinely like to know if anyone in HR tech or people ops has dealt with a version of this, either in the context of analytics tools, ambient sensing platforms, or just transparency in performance systems generally.

Aevron is in early development. This is the thinking behind the HR use case, not a product pitch. If the architecture has a flaw we haven't seen, that's more useful to us right now than a warm response.

We've been building a tool that treats HR decisions as an information problem, not a process problem. Here's what we learned and the tension we haven't fully resolved.

The premise:

Most HR decisions are made on bad information. Not bad intent. Bad information.

Annual reviews are driven by what a manager remembers which is mostly the last 90 days. Priya has been doing the work for 18 months. Months 1-15 are invisible. That's not a manager failure. That's a system failure. And no tool in the current HR stack fixes it because they're all built on the same broken foundation: point-in-time evaluation.

We built Aevron as a cognitive operating system, a tool where people log thoughts, project reflections, training insights, feedback, blockers. The kind of thinking that never makes it into a performance review because it's too raw, too in-progress, too hard to translate into a rating scale.

The architecture we landed on:

Every employee gets a private account. Private means private, raw logs never travel upward. Between the employee's account and everything above it sits a synthesis layer that extracts signal (patterns, growth trajectories, friction clusters, idea density) and sends that upward instead of the underlying content.

Synthesis parameters are set at the org level by admins. Three levers:

• Abstraction depth — how much does the synthesis abstract before signal travels up? At the highest level, HR sees "this employee is developing systems thinking." At the lowest, "this employee has flagged the same cross-team dependency three times this month." No direct content, ever.
• Signal cadence — weekly for managers, monthly for HR, real-time for critical flags
• Explorer scope — which questions HR is actually allowed to ask the system. Admins define the boundary.

Employees can see which abstraction level their org has selected. Not the full parameters, just the level. The logic being: you should know how abstracted your signal is before it reaches your manager, even if you don't control it.

Three scenarios where this changes the actual decision:

Promotion readiness: HR asks for an 18-month thinking trajectory instead of a manager's advocacy at annual review. What comes back: problem framing complexity over time, whether this person's ideas are building on by others, how they've responded to feedback, where they're stuck repeatedly. The decision is now a document, not a political argument.

Training vs. role change: Someone is underperforming. Default HR answer is more training. Aevron separates skill gap (high engagement, missing capability) from fit gap (high thinking quality in the wrong domain) from motivation gap (low idea density, mechanical outputs). These require completely different responses. Traditional HR conflates them constantly and then wonders why training spend doesn't move performance.

Manager quality: This is the one nobody can answer well. Vikram's team ships on time. That's the only data most HR stacks have. What Aevron surfaces instead: does the team generate more ideas together than individually, or is the manager creating dependency? Does reflection quality in the team drop during high-pressure periods — which would suggest the management style suppresses thinking under load? Are early attrition signals showing up before anyone has handed in a notice? The difference between intervening in month 4 and reading an exit interview in month 12 is significant.

The tension we haven't fully resolved:

If employees know their logs feed HR decisions, they'll curate them. Performance theater instead of honest thinking. Signal degrades into managed narrative.

Our architectural answer is that the private account isn't a trust promise, it's a structural guarantee, raw logs physically don't travel upward, so there's nothing to game. The synthesis layer is the only pathway.

But here's what's still open: synthesis transparency. Employees know their org has set an abstraction level, but they don't know exactly what patterns the synthesis is extracting or how sensitive the signal thresholds are. That's a real gap between "your content is private" and "your thinking is fully legible to HR via abstraction."

We've resolved it one way (show the abstraction level, not the parameters), but I'm genuinely not sure that's the right call. The counterargument is that even knowing the abstraction level tells you enough to optimise against it. A smart employee at Level 2 knows that "pattern-level" signal is being extracted, and can adjust accordingly.

The harder version of the problem: is there any amount of architectural privacy that survives the fact that the employee knows a system is watching? Or does awareness of observation always change behaviour, regardless of what the system actually sees?

I don't have a clean answer to that. Would genuinely like to know if anyone in HR tech or people ops has dealt with a version of this, either in the context of analytics tools, ambient sensing platforms, or just transparency in performance systems generally.

Aevron is in early development. This is the thinking behind the HR use case, not a product pitch. If the architecture has a flaw we haven't seen, that's more useful to us right now than a warm response.

Most of the tools solve for the storage of your notes, thoughts, ideas, projects, etc but threads are for the continuity.

There is a difference between them and i will tell you how and why is important.

In Obsidian, a project is something you create. You make a folder or add a tag, decide what belongs there, and keep it organised. So basically, a container is being created and it is live as long as you the one maintaining the container.

Threads in Aevron work on a different layer all together.

A thread isn't something you create. It's something the system recognises. A living semantic object that emerges from your captures over time, maintained automatically, without you having to name it or sort into it.

A thread begins to emerge when Aevron notices that several things you have captured are part of the same line of thought.

Now why it matters is because for example, You might capture something about how people analyse stocks. A few days later, you capture an observation about how people track decisions. Then, you write about conflicting signals and aggregation logic.

Now they might not appear to be of the project but threads recognises the arc and the continuity of the thought and a thread holds that arc alive, keeps the open question live, and surfaces it the next time you return to anything adjacent.

In a traditional notes system, you would have to notice the relationship yourself, manually link the notes, remember to return to the project, and reread everything to reconstruct your train of thought.

There is nothing wrong with that model. But it comes with a cognitive cost. Threads are designed to remove that cost.

When you return to the subject, Aevron does not just show you a collection of related notes. It brings you back to the point where your thinking was still active. That matters because the real problem with most AI tools is not simply memory but continuity.

This is also where it diverges hardest from any RAG on top of Obsidian setup. Those systems can retrieve. They cannot reconstruct the arc. They surface documents. They don't hold the question that was still unanswered when you last left.

The main point is, threads make explicit project management redundant for users operating across multiple domains simultaneously. If the system is tracking the shape of your thinking across captures automatically, you're freed from being the operating system of your own second brain.

It is removing the need to repeatedly explain what you are working on, because the system already understands which thread of thought you are inside.

The connection is the thing most PKM tools skip entirely.

Every serious note-taking system gets good at one half of the job: capture. You write the idea down. You tag it. Maybe you link it to something adjacent. The note exists. What none of them do is tell you what that note means three months later when the context has changed.

Here's what I mean. For example, You capture an observation about your industry in January. In April, you're working through a completely separate problem, a client decision, a research question, a product direction. Somewhere in your vault, the January note is directly relevant. You don't know that. Your PKM doesn't know that. So you work through the April problem without it. The connection that would have sharpened your thinking never happens.

That's not a retrieval failure. You could have searched and found the January note. The failure is that you didn't know to look for it. You didn't know the connection existed. This is the part that gets underestimated: the most valuable connections are the ones you don't know you need.

PKM tools give you search. Some now give you AI-assisted search, you ask a question and it surfaces relevant notes. That's still the same model. You have to initiate. You have to know what you're looking for. The system waits.

The thing that changes everything is a system that finds connections you didn't initiate and couldn't have initiated, because you didn't yet know the two ideas were related.

A researcher I know tracks observations across months. Different projects, different contexts, different questions. The pattern that matters is the one that eventually becomes the insight, exists across six months of separate notes. No search query produces it. It only emerges when someone, or something, is actually reading across the whole body of work and noticing what keeps recurring, what keeps connecting, what seems unrelated but isn't.

That's the job no current PKM tool does.

The tools are designed around your input. You link, you tag, you query. The system reflects your explicit decisions back at you. Which means your graph is only as good as the connections you already knew to make. The unknown connections, the ones across different time periods, different mental contexts, different problem frames and stay invisible.

A connection that surfaces without being asked is worth ten that you found yourself. Not because you're lazy. Because the whole point of externalising your thinking is to see things you can't see while you're inside it.

Your tool shouldn't need you to run it. It should be the thing running in the background, across everything you've ever put into it, finding the shape your thinking keeps returning to and showing you what that shape means before you figured it out yourself.

Have you found any real workaround for the connection problem, or is it just an accepted limitation we've all quietly given up on?

I've been building something that tries to solve exactly this.

The connection is the thing most PKM tools skip entirely.

Every serious note-taking system gets good at one half of the job: capture. You write the idea down. You tag it. Maybe you link it to something adjacent. The note exists. What none of them do is tell you what that note means three months later when the context has changed.

Here's what I mean. For example, You capture an observation about your industry in January. In April, you're working through a completely separate problem, a client decision, a research question, a product direction. Somewhere in your vault, the January note is directly relevant. You don't know that. Your PKM doesn't know that. So you work through the April problem without it. The connection that would have sharpened your thinking never happens.

That's not a retrieval failure. You could have searched and found the January note. The failure is that you didn't know to look for it. You didn't know the connection existed. This is the part that gets underestimated: the most valuable connections are the ones you don't know you need.

PKM tools give you search. Some now give you AI-assisted search, you ask a question and it surfaces relevant notes. That's still the same model. You have to initiate. You have to know what you're looking for. The system waits.

The thing that changes everything is a system that finds connections you didn't initiate and couldn't have initiated, because you didn't yet know the two ideas were related.

A researcher I know tracks observations across months. Different projects, different contexts, different questions. The pattern that matters is the one that eventually becomes the insight, exists across six months of separate notes. No search query produces it. It only emerges when someone, or something, is actually reading across the whole body of work and noticing what keeps recurring, what keeps connecting, what seems unrelated but isn't.

That's the job no current PKM tool does.

The tools are designed around your input. You link, you tag, you query. The system reflects your explicit decisions back at you. Which means your graph is only as good as the connections you already knew to make. The unknown connections, the ones across different time periods, different mental contexts, different problem frames and stay invisible.

A connection that surfaces without being asked is worth ten that you found yourself. Not because you're lazy. Because the whole point of externalising your thinking is to see things you can't see while you're inside it.

Your tool shouldn't need you to run it. It should be the thing running in the background, across everything you've ever put into it, finding the shape your thinking keeps returning to and showing you what that shape means before you figured it out yourself.

Have you found any real workaround for the connection problem, or is it just an accepted limitation we've all quietly given up on?

I've been building something that tries to solve exactly this, happy to share more if anyone is curious.

I've been building a tool called Aevron for a few months now and the single strangest thing about it compared to Notion or Obsidian is this: it tracks how your thinking evolves, not just what you've captured.

Every other PKM I've used is essentially a very good filing cabinet. You put ideas in, you retrieve them later, you make connections manually. The intelligence is yours to supply every single time you open it. The tool is passive by design.

Aevron does something I haven't seen elsewhere. It builds a model of you as a thinker across sessions. It knows when you've contradicted a position you held three weeks ago. It knows when you've circled the same unresolved question twice without landing anywhere. When you make a confident claim, it can surface the moment that confidence started to crack. That's not a PKM feature. That's closer to having a thinking partner who actually read everything you wrote and formed an opinion about your reasoning patterns.

The weird part isn't that it challenges you. It's that the challenges are grounded in your own history, not generic Socratic prompts. It's not asking "but have you considered the other side?" It's saying: you argued the opposite of this in July.

Curious if anyone else has run into tools that do something similar or if this is genuinely a different approach within PKM tools.

Check out Aevron at www.aevron.co

Most PKMs store what you think. Aevron tracks how your thinking changes and holds you accountable to it.

It knows when you contradict yourself, when you've circled the same unresolved question twice, when a confident position quietly collapsed under challenge. It doesn't just archive your notes, it builds a model of you as a thinker, then uses that model against you in the best possible sense.

Notion, Obsidian, Roam, they are all sophisticated filing systems. The intelligence is yours to supply, every time. Aevron supplies some of it back.

Most PKMs store what you think. Aevron tracks how your thinking changes and holds you accountable to it.

It knows when you contradict yourself, when you've circled the same unresolved question twice, when a confident position quietly collapsed under challenge. It doesn't just archive your notes, it builds a model of you as a thinker, then uses that model against you in the best possible sense.

Notion, Obsidian, Roam, they are all sophisticated filing systems. The intelligence is yours to supply, every time. Aevron supplies some of it back.

You've been building a second brain for years. It still doesn't know you.

Obsidian. Notion. Roam. The whole setup. Tags, backlinks, MOCs, beautifully organized and it holds everything equally. The idea that changed how you think about the something sits next to the note you wrote on a Tuesday and never opened again. Same weight. Same silence.

Your PKM doesn't know the difference. You do. And you have to carry that every single time you open it. That's the real ceiling. You are still the operating system.

You do the linking. You do the synthesis. You decide what's relevant right now. The vault just holds pieces. You do all the work of understanding how they fit. That's not a second brain.

The most common thing I hear from serious PKM users: "I have to remind it though." Elaborate systems. Backlinks, review cycles, daily notes. And still, every session starts with manually re-orienting the whole thing. Because the system doesn't know what you're working on. It just knows what you stored.

What's actually missing is something that brings the right context forward on its own. Not because you tagged it right three months ago but because it understood what the idea was and why it matters to what you're doing now.

When you're developing something today, it connects it to the thread you were pulling a few weeks/months ago. Without you having to remember that thread existed.

That's what Aevron does.

Every PKM solves storage. Aevron compounds. Your thinking gets more useful over time, not just more voluminous.

Early access is open if you spend more time maintaining your PKM than actual thinking with it.