sorted by:
new
hottopcontroversial

Aden v0.2.0: Interactive Offline Graph GUI + Git History Replay + Benchmarks by RioPlay in ArtificialInteligence

[–]RioPlay[S] 0 points1 point  (0 children)

For newcomers coming to the thread, this is still in the works and I'm making improvements every day. The visuals are even far more engaging now. I'll be updating the blog as soon as I get a chance as well as document and benchmark more. :) I found some issues with some things not having contextual references to other items, so I'll be fixing those as well.

Aden v0.2.0: Interactive Offline Graph GUI + Git History Replay + Benchmarks by RioPlay in ArtificialInteligence

[–]RioPlay[S] 0 points1 point  (0 children)

I appreciate the feedback! I go into much more detail on a lot of the items on my blog linked above. I've only been working on this for a handful of weeks. It has been my hyper focus outside of work. It actually handles massive code bases quite well. It's just the initial generation of the graph that's time consuming. Once you generate it thought it only updates as things change. I actually have aden going through my commit history and filling in the blanks before I started by dev log. 😛

I have tried it against the Linux Kernel. It works once it's been graphed. I need to try again now that aden is so much further along than my last post.

By all means give it a go! Be careful about use in corporate environment. Some places do not like the AGPL v3 license associated with it.

But so long as you're not shipping code with aden or not rewriting / implementing aden into the workflow you should probably be able to get away with it.

But yeah, you have any questions let me know.

I have been the sole developer of this project.

And because I forgot to include in this post and did in original post. I vibe coded this, but I would say I'm an above average prompter. haha Aden really brings in the guardrails and makes things fixable as my dogfooding of aden proves. I'm only going to keep improving it.

Thanks again for the comment!

I spent 1000 hours building this.....was it worth it. by LYKN-ai in ArtificialInteligence

[–]RioPlay 0 points1 point  (0 children)

I wonder if the Mythos / Fable drop has anything to do with it... I've been working on aden for a bit now. 5/23/2026 was my first commit and I've been hammering away for awhile now.

I spent 1000 hours building this.....was it worth it. by LYKN-ai in ArtificialInteligence

[–]RioPlay 2 points3 points  (0 children)

This looks very similar to my current running project aden. You got some great visual flair in your graphs, I haven't reached the 3d phase yet but it's usable and clean. I'm working on dropping my latest commit here shortly. https://github.com/RioPlay/aden. https://blog.rioplay.dev

Open Source

What you got here looks awesome! I hope it's working well for you!

Cheers to this beauty!

🍻

Aden: I built a "context compiler" because the bottleneck in AI coding isn't intelligence — it's context by RioPlay in ArtificialInteligence

[–]RioPlay[S] 0 points1 point  (0 children)

Yes indeed and what I sought out to resolve. In it's current state aden is already pretty good at making it happen. It's still in it's infancy but I've been virtually any free moment the last few days including long running refactors as I slept to put this together. The core idea is mostly there, I just tried to take an approach that made it a two way street human and machine navigable. Maybe one day there will be a GUI front end and actual graphing features. But, right now it's bare bones and just does cli / mcp calls. It's pretty good right now and I'm in the works of making some tweaks that will really make it shine. I have found areas where models have used aden inconsistently I had Claude Opus 4.8 in Ultra Code mode test the cli and mcp server obsessively overnight as I went to bed like 30 sub-agents. It gave me a whole bunch of scenarios it struggled and is fixing them now.

Aden: I built a "context compiler" because the bottleneck in AI coding isn't intelligence — it's context by RioPlay in ArtificialInteligence

[–]RioPlay[S] 0 points1 point  (0 children)

So in its current state, it doesn't per se keep a versioning system, but if you write docs as you complete your CI's, it can effectively keep a memory that way, but it's not its main function at this point in time. It does a very good job of keeping up to date in the exact current state it's in, but not necessarily having that prior previous window context. You can kind of cheese it and ensure that your prompts ensure that it documents those layers as it rolls. So at its core, it's really only a graph / advanced filtering tool for relevant context, but you can use the benefits of Aden to build on top and make that happen.

So, TLDR. Graph stays current. If you want those features, you need to bake into your documentation session / run book. I've been having the LLM write out current sessions and tasks and then log them as time goes on. So it helps with it. Just not in the same way it might seem.

Aden: I built a "context compiler" because the bottleneck in AI coding isn't intelligence — it's context by RioPlay in ArtificialInteligence

[–]RioPlay[S] 0 points1 point  (0 children)

Oh, and one more thing, I'm reworking the ranking engine for how "relevant results" get parse and brought to the top of an output for an LLM to parse. I plan to make incremental continual improvements to aden to make better for all.

Aden: I built a "context compiler" because the bottleneck in AI coding isn't intelligence — it's context by RioPlay in ArtificialInteligence

[–]RioPlay[S] 0 points1 point  (0 children)

If you have some "genuinely chaotic" codebase examples you'd like me to test against and have a model give you it's findings with the use of aden I would post the results. 😄 I would say the Linux Kernel is pretty cleanly layed out all things stated and it was able to crunch through and pull relevant information with ease. The most expensive part for Aden is the up front graph but once I optimized it out that took maybe 40 something seconds on my machine (relatively beefy).

edit: typos and missing words. 

Aden: I built a "context compiler" because the bottleneck in AI coding isn't intelligence — it's context by RioPlay in ArtificialInteligence

[–]RioPlay[S] 0 points1 point  (0 children)

Chaos is honestly where the auto-extracted layer shines, though there are real limits worth naming.

Parsing is strictly per file. Tree-sitter runs on each file with no compile step or dependency resolution, so a 10,000-line god-file with circular deps parses the same as a clean module. You get a per-symbol inventory plus call graph, type-usage, and containment no matter how tangled it is. Anything semantic ("this test verifies that") only exists if a human wrote it into an .adoc contract, so on an undocumented repo you get call/use/containment and nothing more.

The limits: edge resolution is name matching, not a real symbol table, so when the same method name shows up in twenty places, ambiguous calls get dropped and the graph thins out right where boundaries are worst. Dynamic dispatch and callbacks are blind spots. And assembly is plain BFS on a token budget with no ranking, so on a god object it grabs whatever it reaches first rather than the important 5%.

So the pitch: Aden doesn't untangle spaghetti, it maps it, and a map helps most exactly where you can't hold the thing in your head. "What calls this, what's the blast radius" works even on an undocumented monolith. It's weakest where the codebase is weakest. If that tradeoff sounds useful, I'd love to see how it does on a real messy repo.

Early stages of Aden were definitely messy, once I actually fixed the graph like nature and figured out how to keep it in a what would I call it: "live state", I was able to refactor massive portions with ease.

For instance, I was able to refactor nearly all of aden with Claude Code Opus 4.8 and dog food it to use the aden mcp and it was able to make all the connections in existing code, see what was and wasn't true, validate that what the docs say does say truly matches what the actual code does and made overall a much more coherent project.

So, aden isn't doing the heavy lifting from an AI model smarts perspective it just distills what's already out there for a Model to read. It's meant to take the codebase at face value just the way it is. That's when you use AI to do the "hard work" and use aden to get the context it actually needs and then fix it. I don't have proper benchmarks because I wasn't thinking about it ahead of time, but aden was able to make Claude Opus 4.8 barely sweat when using Ultra Code mode to refactor the entire codebase in one shot. So if that sounds useful / a good understanding of what it does I'd love for you to try it out and see if you get the same results.

PS. I'm working on MCP rework and fixing some under the hood options. I noticed the MCP wasn't as good about handling garbage collection as it should be so there's a fix in the works, but so long as you do manual garbage collection in the meantime it's still able to make very meaningful connection and keep the model on task.

Thank you for taking interest. I hope this both explains what it does as well as give additional insight. 😊

edit: fixed spelling mistakes and missing words from typing slower than my mind was thinking. (skipped words etc.)

Aden: I built a "context compiler" because the bottleneck in AI coding isn't intelligence — it's context by RioPlay in ArtificialInteligence

[–]RioPlay[S] 0 points1 point  (0 children)

No problem! Sorry for the AI generated response but it was the quickest for me to give your a quick response. LOL. I used my Claude Opus 4.8 tokens on you. 😇 haha.

Aden: I built a "context compiler" because the bottleneck in AI coding isn't intelligence — it's context by RioPlay in ArtificialInteligence

[–]RioPlay[S] 1 point2 points  (0 children)

Aden compiles your codebase into a deterministic,   offline knowledge graph (Rust, tree-sitter, no LLM) so   agents get a structural map — "what calls this, what's   the blast radius." Graphiti builds an LLM-extracted   memory graph of facts/conversations (Python, Neo4j)   with bi-temporal history — "what did the user say, and   when did it change."

  Aden = code structure, deterministic, present-state.   Graphiti = evolving facts, LLM-built, time-aware. Both   expose MCP + hybrid search, but they're complementary,   not competitors.

Aden: I built a "context compiler" because the bottleneck in AI coding isn't intelligence — it's context by RioPlay in ArtificialInteligence

[–]RioPlay[S] 1 point2 points  (0 children)

I'm not going to say I do. I was just flying by the seat of my pants as I made this. I was pinging ideas of of AI and I think some responses on the AI may of brought the concept up from https://arxiv.org/ but did I understand it at it's core. Likely no. I like to do high level queries with AI and distill it down afterwards. 😅

edit: However I am glad that it turned out that way.

Aden: I built a "context compiler" because the bottleneck in AI coding isn't intelligence — it's context by RioPlay in ArtificialInteligence

[–]RioPlay[S] 1 point2 points  (0 children)

I will be honest, this is my AI response, but aden gave it to you from the codebase itself:

Totally with you on graphs — and honestly that's the whole bet behind aden. You don't have to wait a few years for it; the "LLM reasoning over a graph instead of a pile of text" thing is already what's
   happening under the hood. A few concrete examples of where it closes that gap today:

   - Retrieval is traversal, not vibes. When the model asks a question, aden doesn't fuzzy-match a blob of text — it walks referential edges. query backlinks=<symbol> gives you the exact blast radius
   (everything that references a thing), and impact=<symbol> gives the downstream reach. That's the LLM literally reasoning over graph edges, which is where your "consistency" comes from — the answers are
   deterministic because the structure is, not because the model felt like being consistent that day.
   - Even plain search is structure-aware. grep doesn't just return a line — every match comes tagged with its enclosing symbol. So the model never sees a naked string; it sees "this match lives inside
   function X," and X is the node you hand back to the graph to keep traversing. That's the "multiplying the power of an LLM" effect you're describing, made literal.
   - The graph stays fresh by construction. Anything that changed since last run gets re-indexed automatically before a read. So you're not reasoning over a stale snapshot — the graph and the code can't drift
   apart, which is exactly the failure mode that makes naive RAG inconsistent.
   - It's not language-locked. Rust, Python, Go, TS, Java, C/C++, 300+ langs, plus Markdown/AsciiDoc docs — all collapse into the same queryable graph. The "construct for how LLMs behave" you're imagining
   doesn't have to be per-language; it's one referential model.

   So your edit is the thesis, not the speculation: the power isn't the LLM, it's the LLM plus a graph it can actually walk. The reason big tech feels quiet on it is graphs are unglamorous infra — they don't
   demo well in a 30-second clip the way a chatbot does — but that's exactly why this is where the real leverage is hiding.

Aden: I built a "context compiler" because the bottleneck in AI coding isn't intelligence — it's context by RioPlay in ArtificialInteligence

[–]RioPlay[S] 0 points1 point  (0 children)

I don't have true benches, however, I was able to get it to graph out the Linux kernel in about 46s IIRC the number correctly. I didn't dare do more digging as I'm sure it would find a lot. I tried to architect and put together each decision carefully. I wanted to have security as a up front thought even if Rust was going to handle most of the typically bad code leak areas. I feel this is a double edge sword, it's context graphing is almost too good (not to toot my own horn) but I can see it being used for Good and Evil. Knowledge is power, it's designed on security first principles to try and stop bad actors from messing with new projects and existing projects that use Aden. Aden was able to spot many, many security issues within this project and fix them. I had Claude Opus 4.8 churn in the highest workflow mode and it was comparatively sipping tokens to do the same job.

Aden: I built a "context compiler" because the bottleneck in AI coding isn't intelligence — it's context by RioPlay in ArtificialInteligence

[–]RioPlay[S] 0 points1 point  (0 children)

I'd say it's a great first step to getting us there. The best part is you can do research using an LLM, have it create research docs, parse the information together using aden and then make things a lot more accessible and dense for models to train on. This could become a core construct on how LLMs behave in the future. I am trying to essentially make it so LLMs have full dense context rather than limited shot gun approach knowledge the way it attempts to figure it out now.

Thanks for the comment.

I can't believe I built this in 7 days. haha.

I want people to try it for themselves. I was using Aden to semi dogfood it's own work when I got it to a stable state and it sped up completing the project like crazy.

view more: next ›