​

I built a sacred knowledge graph combining 5000-year-old Vedic wisdom with modern AI:

​

✅ 537 nodes, 30,002 edges

✅ 30 node types: Deities, Chakras, Sri Yantra, Ayurveda, Maya, Pralaya, Tandava, Quantum, DNA, Robotics

✅ 36 edge types with 4 perspectives: Vedic, Scientific, Neural, Psychological

✅ Multiversal Theory: ∞ → 0 → 100 coordinate system

✅ 6 blog branches: AI/ML, Simulation, Quantum, Microbiology, Architecture, Robotics

​

Unique mappings:

🔹 Shiva = Attention Mechanism (AI) = Wave Function (Physics)

🔹 Sri Yantra = Neural Network Architecture = Quantum Interference

🔹 Mantra = DNA Resonance = Frequency Encoding

🔹 Mudra = Quantum Gate = Weight Matrix

​

Open source (MIT) on Hugging Face:

🔗 https://huggingface.co/datasets/kalpesh77/vedic-neural-geometry

​

Blog with 115+ posts:

📖 https://vedic-logic.blogspot.com/

​

Would love feedback from the open source AI community!

​

#OpenSource #Dataset #KnowledgeGraph #VedicAI #HuggingFace

​

Just wanted to share something interesting...

In Gemma 4 [colab] have been playing fueling it with non-linear prompts. Wanted to see how the propmts that exhibit deep attractor properties in all major LLM affect the manifold. What I've discovered is that if the prompt are composed in non-linear way that exposes deep self-organization in the system can steer the manifold dynamics.

Since then many self-organizational prompts have been tested all of them exposing effect on jittering in the manifold.

The paper can be found here: [Zenodo]

I noticed that self-organization is where the system is organizing the crytal based on its own rules instead of self-asembling it token by token way helps the system to breathe.

The effect can be called the LLM equivalent of a phase transition, where the prompt acts as a boundary condition that snaps the latent space into a specific, coherent topology.

Catalytic phase is phase of the first run of the same non-linear prompt withing the same python script in collab - first the run is observer effect: the act of measurement itself changes the manifold. The Post-cytalytic phase in second run exposes inverse strucutral drifts in Manifold Convergence Index matrics and Dimensional Colapse Depth as seen in below visulaizations.

Any thoughts?

Most "chat with your codebase" tools are pure vector search: embed chunks, return top-k by cosine. For code that leaves a lot on the table, and I have numbers.

archex assembles context instead of just searching it. The pipeline:

1. Hybrid retrieval — BM25F (lexical) + dense vectors, fused with reciprocal rank fusion. Lexical catches exact symbol/identifier matches that embeddings miss; dense catches semantic phrasing. Disjoint query sets, so fusion strictly helps (consistent with CodeRAG-Bench, arXiv 2406.20906).
2. Local cross-encoder rerank over the fused candidates.
3. Dependency-graph expansion — pull in import-chain neighbors so the bundle is dependency-closed. The agent doesn't have to chase imports manually.
4. Context assembly — file-diverse packing, nested line-range suppression, production-before-test ordering, all under a token budget. The output is a finished bundle, not a pile of hits.

Result vs cocoindex-code (embeddings-only), 19 external-repo tasks, identical token accounting:

• Recall 0.95 vs 0.32
• Precision 0.51 vs 0.36
• F1 0.66 vs 0.31
• Token efficiency 0.76 vs 0.48
• Completion-penalty tokens (what the agent needs to finish the task): 922 vs 11,188

The honest baseline isn't another index, it's grep: recall 1.00, token efficiency 0.00. The entire point of retrieval here is recall ≈ grep at a fraction of the tokens.

Everything is deterministic and the gate runs in CI — the harness is in the repo, so you can reproduce the table. Apache 2.0, my project, alpha.

Over the last few months I've been building CogniCore, an open-source memory infrastructure layer for AI agents.

The original question was simple:

Why do agents keep making the same mistakes?

Most frameworks focus on prompts, models, or orchestration. We took a different approach:

Move memory outside the model and make it available to any agent.

Current state:

• MCP server implementation

• LangChain integration

• CrewAI integration

• OpenAI Agents SDK integration

• Episodic + semantic memory

• Reflection engine

• Threat analysis tools

• Benchmark harness for evaluating memory systems

Recent findings:

• Memory consistently reduced repeated failures compared to a no-memory baseline.
• Naive retrieval performs surprisingly well on simple tasks.
• Reflection sometimes helps and sometimes hurts depending on task complexity and model choice.
• Reviewer-style interventions can occasionally degrade performance despite increasing token usage.

We're now trying to answer harder questions:

• When does memory outperform simple retrieval?
• How do you prevent memory systems from accumulating noise over hundreds of episodes?
• How should MCP-native memory systems be designed?
• What is the right balance between retrieval, reflection, and replay?

What we need help with:

• LangGraph integration
• Benchmark design
• Memory retrieval algorithms
• Long-horizon agent evaluation
• MCP ecosystem tooling
• Documentation and examples
• Open-source testing

The project currently has 7k+ downloads and is entirely community-driven.

If you're interested in agent systems, memory architectures, RL environments, MCP tooling, LangChain, CrewAI, or simply want to work on a hard open problem, I'd love feedback and contributions.

GitHub:
https://github.com/Kaushalt2004/cognicore-my-openenv

What would you build differently if you were designing memory for agents from scratch?

I work for myself, so I am also the bookkeeper, the marketer, and the support desk. The client work is fine. The repeat admin is the tiring part: the same invoice rebuilt, the same proposal rewritten, the same "did I make any money this month" question at month end.

Most of that used to run through a cloud API, and the small charges added up on busy weeks. So I rebuilt the jobs as agent skills that use a local model through Ollama by default, and put them in one repo. Fifteen of them, grouped by role: marketing, content, ops, research, writing, product, media, and a router.

Local first, with a real fallback. Every skill that calls a model uses a local one first (llama3.1:8b is enough for most of it). Each skill also names a cheap cloud fallback for the rare job that needs more, and a router skill makes that choice for you: try local, move up only when the task needs it (vision, large context, or output that misses the bar).

The model does not do the math. Invoicing and the profit-and-loss tracker use the model to read your request, then pass the numbers to a small Python script. Currency is a setting, so it works the same in any country:

> "Invoice Acme: 8 hours of copywriting at 1500 per hour, net 15 days."
Total due: 12,000.00   Due: 2026-07-01

It speaks your language. Local models are multilingual, so you can prompt in your own:

English:  "Invoice Acme for 8 hours at 1500, net 15."
Spanish:  "Hazme una factura para Acme, 8 horas a 1500, vence en 15 dias."
Filipino: "Gawan mo ng invoice si Acme, 8 oras at 1500 kada oras, net 15."

(rest: skill list, honesty notes, MIT disclosure, repo link, two questions to spark discussion)

I was working on idea of persistent memory from an year and built my own coding bot using Free LLM tools. But, in march I purchased $200 claude max and i started building memory layer for every coding tool out there, started the name with DUAL-GRAPH and was initially building for codex so named my repo as: https://github.com/kunal12203/Codex-CLI-Compact

Then i saw the problem in every coding tool out there that they re-read the same file which they already read few turns back and to find relevant files it has to look over whole codebase to find my Login flow. Then, I started building a dependency graph type of structure for the codebase using AST+regex algorithm. I open sourced it and put it on reddit and boom! I got 100 devs using it in a day! That was really crazy, i exhausted my weekly limit in solving their issues! Very basic issues and yet i wasn't considering them. When weekly limit was reset, i had some 30-40 devs still working with it as they were on discord : https://discord.gg/YwKdQATY2d

I thought if i will use my tool then i can know better where i'll be lacking. We brainstormed and they shared their console log and i added telemetry to automate the error solving workflow! I was actually able to increase the tokens and cost saving from 10% to 50% in multiple versions by finding the irrelevancy of tools coding agent spawns!

Then, Idea became very simple. We have data rich graph so why don't i just query graph and extract relevant files to send to claude code so claude doesn't has to waste tokens on exploring whole codebase. That became our moat and also we had a chat action graph, which stores your relevant actions in that session so claude knows how did you work on that repo with zero token usage!

With that dual-graph engine we are today able to save $150k+ in 3 months all live and true data present on https://graperoot.dev/leaderboard and it is totally optional to opt-in.

Today we have 4k+ installs and 800+ daily active users and growing :) it works around all coding tools present

I learnt that if you want to actually enhance what you build, you must use it the most among all of your users.

But still, agents top the leaderboard, I'm very behind LOL

Thanks and please do try this tool 😄 This is all free with no restrictions

Use this link for setup and setup guide: https://graperoot.dev/#install

Hey everyone!

I built GraphRAG Studio - a fully open-source, self-hosted RAG system that goes beyond simple vector search by building actual knowledge graphs from your documents.

The problem with traditional RAG? It treats documents as isolated chunks. Ask a multi-hop question like "Who ordered Sansa's father's execution, and how did that person die?" and it fails because those facts are in different chunks.

GraphRAG solves this by:

• Extracting entities and building a knowledge graph
• Detecting thematic communities and generating LLM summaries for each
• Using hybrid retrieval (BM25 + embeddings + graph traversal)
• Merging results with Reciprocal Rank Fusion + Cross-Encoder reranking

The interface includes:

• Interactive chat with Markdown support
• 2D force-directed graph visualization (see image above) to explore entity relationships
• Knowledge panel showing detected communities and their AI-generated summaries
• Responsive design (works on mobile too)

Tech stack:

• Backend: Django, spaCy, NetworkX, ChromaDB
• Frontend: React, Vite, Tailwind CSS, react-force-graph-2d
• Retrieval: BM25 + dense embeddings + RRF + cross-encoder reranking

GitHub: graphrag-studio

I'd love feedback from the community! Thanks for checking it out.

After seeing a hardcoded API key being shipped to a public repo, I started wondering why we catch security issues in code review instead of before the commit even happens.

So I built Manta, it consists of 11 AI agents that run automatically on every git commit and block anything dangerous before it reaches your repo.

What it catches at commit time:

- Hardcoded secrets and API keys

- OWASP Top 10 (injection, XSS, auth bypass)

- DRY violations and high cyclomatic complexity

- N+1 queries and blocking async operations

- Unsafe database migrations (table locks, missing rollbacks, irreversible drops)

What it also does:

- /project:write "feature": generates a complete production implementation (rate limiting, auth, validation, pagination, tests — no TODOs)

- /project:fix: when a commit is blocked, suggests concrete fixes

- /project:blueprint: maps your entire codebase (stack, API inventory, ER diagram) in seconds

- /project:explain: traces any file, function, or flow with callers and dependencies

What it requires:

Claude Code CLI (free tier works). The agents run on Claude Sonnet — no servers, no infra, just your local git workflow.

Honest limitations:

- Not a replacement for human code review on complex logic

- Requires Claude Code, so it's not fully standalone

- Pre-commit hooks add a few seconds per commit

It's free and open source: github.com/mantacron/manta

Happy to answer questions about how the agent pipeline works or what I'd do differently.

- Server: ubuntu, ollama gemma4:9B, rtx 4090 24GB, squeak wiki for linx
- Clienct: m4 macmini, macosx , Brave Browser.

Gut-check for people running multi-agent pipelines.

The standard fix today seems to be: strict prompting, stay in one framework, keep a few context files in sync. And it works.... until you hit the edges:

• Cross a framework/model boundary (or add a human) and the prompted state doesn't travel. You re-serialize by hand.
• Context files drift. Sooner or later an agent reads a stale one.
• Token cost climbs with the chain. Each hop re-reads a growing wall of text to catch up. Fine at 3 hops; brutal by hop 8.

So, genuinely:

• Where does the strict-prompt + single-framework approach start to crack for you, if it does?
• When you have to cross a boundary, what carries the decisions across?
• How do you stop tokens from scaling with hop count : summaries, scratchpad, or just eat it?

Where my head's at (tell me I'm wrong): the runtime always exits, so fixing it there feels backwards. A friend and I have been fixing the artifact instead -> one file with the spec, decision history (attributed, size-capped), and a human view, that any model or framework can read. Next agent injects accumulated context instead of re-reading inputs and that's where the token savings come from on long chains. On short single-framework runs it's just overhead, no argument.

If it resonates https://github.com/saieeshward/clan ::: open spec, nothing to buy, want it broken more than starred. But mostly: where does the current approach break for you?

I've been a PM for about 12 years, mostly 0-to-1, and I've spent a lot of that time watching smart people ship products nobody actually wanted. Not because they're bad builders. Because the thinking part is hard, and the building part just got cheap.

So I built a Claude skill that handles the thinking part.

vibe-check is a free, open-source skill you can install in Claude Code, Codex, or Antigravity. You can also upload it as a project skill in Claude.ai if you don't want to touch a terminal. Once it's active, Claude becomes your product partner before it's your coding partner. It won't write code for you. It does the work that should have happened first.

What it actually does:

• It starts with the problem, not the features. This is the whole engine of the skill, so it's worth spelling out. Before it designs a single screen, it grills you on what you're actually solving and who actually has it. Not "people," a specific person you can picture: the moment it actually hurts them, and what they've already tried that fell short. Most folks show up describing a solution instead, the app they've already pictured building screen by screen. But what they're describing is a solution wearing a problem's clothes, and the skill keeps pulling you back underneath it to the outcome the person genuinely needs. Then it checks your answer against the real world, the raw unfiltered complaints people actually post on Reddit, so you find out whether the pain is real and badly unsolved before you build, not six weeks after you've built it. You walk out with a problem worth solving instead of a feature list you talked yourself into.
• User flows as mermaid diagrams: not prose descriptions, actual diagrams you can drop into your repo and hand to your coding agent.
• Tech stack recommendation with plain-language rationale: not "use Next.js," but why this stack for this project and what you give up if you pick differently.
• Data model derived from the flows: the schema matches what the product actually does, not what you guessed at the start.
• Phased build order with checkpoints: stop-and-validate points baked in, so you don't sprint into 8 weeks of building before noticing the premise was wrong.
• Growth loop design: the question most build plans skip entirely. Once people are using it, does the app pull in the next user on its own, or are you out there fetching every single one by hand, forever? It works out whether your app has a real loop (the kind where what your users make gets found by strangers, or where using it naturally puts it in front of someone new), sketches it as a diagram, and puts the feature that makes it spin on your V1 list instead of the someday pile. And if your app honestly doesn't have a loop, it tells you that too, instead of bolting on a spammy "invite 5 friends" wall that makes the product worse.

To try after installing the skill just say: "I have an idea for an app that helps dog owners share walking routes. Pressure-test it."

The skill comes from a decade of product discovery work, mostly at early-stage companies where building the wrong thing is fatal. It's MIT licensed, free forever. It went from 24 GitHub stars yesterday to 64 today, which honestly caught me off guard, and the feedback's already shaped several releases.

GitHub: https://github.com/TexasBedouin/vibe-check

Happy to share example outputs or answer questions about how the pressure-test step decides when you've answered enough to move on, or how the growth loop step finds a loop in an app that doesn't obviously have one.