←
Nishkarsh2,814 posts
Nishkarsh avatar

Nishkarsh

@contextkingceo

Founder @Hydra_DB | graphs x agents

◷ Joined August 2020▧ 253 Photos and videos
Jayking♟️ avatar
⟳ Nishkarsh retweeted
Jayking♟️@__Official__1·Nov 16

Building Kynthera with @hydra_db went far beyond the interface. From GraphBLAS and Rust build issues to deploying HydraDB, I learned a lot about turning failures into reusable recovery knowledge. I documented the entire journey here: dev.to/__official__1/buildin… Check it out guys!

Post attachment

Introducing Kynthera, my submission for the @hydra_db Hackathon. Failure is data. Recovery is intelligence. While building AI-powered systems, I noticed a recurring problem. When something breaks, developers investigate, find a solution, and move on. But that knowledge often gets lost, leaving the next developer or agent to solve the same problem again. I built Kynthera to change that. It's a recovery intelligence workspace built on the open-source HydraDB engine, connecting incidents, recovery strategies, and verified outcomes into reusable knowledge. Here's what I've implemented: • Incident capture and failure tracking • A HydraDB-backed recovery knowledge graph • Recovery strategy recommendations • Success and failure feedback • A replay lab for evaluating recovery decisions • A dashboard for exploring previous incidents and recovery patterns One of the most interesting parts was getting HydraDB running locally. I encountered missing LAGraph dependencies, GraphBLAS configuration issues, Rust linker failures, and authentication problems while connecting my local graph node to the deployed application. After working through those challenges, I got the open-source HydraDB engine running on WSL and connected it to Kynthera's live frontend. The goal is to make recovery knowledge improve over time. Instead of treating every failure as an isolated event, Kynthera preserves what happened, which recovery strategy was used, and whether it worked. This is an early implementation, and measuring recommendation improvements against a baseline is an important next step. I see applications for AI agent developers, DevOps teams, and anyone managing complex automated workflows. You can explore the project here: Live app: kynthera.vercel.app GitHub: github.com/paulos-ui/Kynther… Demo walkthrough: loom.com/share/78cb0770200c4… Built with the open-source @hydra_db engine. The bigger idea is simple: AI systems should become better at recovering from the failures they've already encountered.

Post attachment
yashyadav avatar
⟳ Nishkarsh retweeted
yashyadav@yashastro23·Nov 16

Every browser agent visits the same site like it's the first time. It reads the page, asks the model, clicks, and repeats. Tomorrow it pays for all of it again. I built Atlas: a shared map under every browser agent, built on @hydra_db 🧵 @jaywyawhare @contextkingceo @TheVixhal @HelloVyom

2:29
Nishkarsh avatar
Nishkarsh@contextkingceo·Nov 14

The idea is to make sure that no matter what graph store you use (postgres, neo4j, hydradb) you should have a standard, simple, and delightful way for building graphs for your agents! This is like next.js but for building agent graphs

Meet SelfGraph: An open-source framework for building a living product graph for your AI agent. Imagine having an AI agent that continuously understands your product and can recommend what to build next based on the latest research, market trends, and client requirements. Whenever a new research paper, blog post or Hacker News discussion relevant to your product niche appears, your agent can connect that information with client meeting notes, Linear/Jira tickets and existing product context using SelfGraph. With this continuously evolving product graph, your AI agent can figure out what to build next, spawn agents to implement ideas from the latest research or address client requirements and create or update Linear/Jira tickets accordingly. Your product context keeps evolving and your AI agent evolves with it.

Nishkarsh avatar
Nishkarsh@contextkingceo·Nov 14

Constantly on top of the things that we wanted and wished existed…LOVE THIS

Introducing SelfGraph. The open source framework for building agent graphs. Turn unstructured text into a graph your agents can query. Every fact keeps its source. Same framework. Any graph store. Link in comments.

0:51
Nishkarsh avatar
Nishkarsh@contextkingceo·Nov 13

Let's see what builders with unlimited access to agents, software, context graphs can do

Final few spots open. If you’re a builder who wants to see what one person can do with a team of AI agents, come spend 20 hours building with us this Friday.

Nishkarsh avatar
Nishkarsh@contextkingceo·Nov 10

hard to believe these videos until last year required 3 people for scripting, motion graphics, sound etc etc

HydraDB reads your data as it is, lifts out the people, projects and dates, and connects them into one graph. Every new source joins the same graph. Enabling agents to get the most accurate context.

0:28
satyam avatar
⟳ Nishkarsh retweeted
satyam@satyamsharma_33·Nov 10

Moving an existing graph database to a new system shouldn't mean rebuilding your graph from scratch. @hydra_db is working on making that transition easier. Its v0.3.0 release introduced FalkorDB import tooling. Here's what's interesting: You can inspect and scan FalkorDB dumps, plan an import, and migrate graph data into HydraDB's object-store-backed architecture. It also introduces offline graph images, allowing durable graph state to be prepared outside the live database and bulk-loaded later. Why does this matter? Because database migration isn't just about moving records. You need to preserve graph identity, relationships, and durable state while making the import predictable. I find this an interesting direction for HydraDB: building not just a graph database, but tooling around how real applications can move to it. Release notes: github.com/hydra-db/hydradb/…

HydraDB avatar
⟳ Nishkarsh retweeted
HydraDB@hydra_db·Nov 6

Grafana now ships a knowledge graph in every Cloud stack, so its agents know how services, databases and users connect. HydraDB builds that permission aware graph for your agents, across 70 apps. Try out today 🫵

Post attachment
Lily yang avatar
⟳ Nishkarsh retweeted
Lily yang@lilyyang169·Nov 6

Founders in NYC: @Tiny_Fish is hosting a private dinner with @gen_legal_inc and @hydra_db We will be inviting our friends and also welcoming new faces to join us. Register below to meet our team in person in NYC for our first private event!

Post attachment
Jeremy Morgan avatar
⟳ Nishkarsh retweeted
Jeremy Morgan@JeremyCMorgan·Nov 5

What if graph databases kept durable state in S3 and treated query workers as disposable compute? HydraDB explores that architecture using Rust, SlateDB, and GraphBLAS. An interesting experiment in separating graph storage from execution. github.com/hydra-db/hydradb

Nishkarsh avatar
Nishkarsh@contextkingceo·Nov 4

I learn SO much from you everyday

First a CPU, then a GPU. A computer isn’t complete without storage. Meet qwenFS: Qwen3.5-2B with a filesystem compiled directly into its weights. Nothing runs outside the model. It adds 8 layers in front of Qwen’s own 24, using attention to hold the files and Gated DeltaNet state to hold the tables. Every save and read runs in the model’s own forward pass. A write stores its text in the copy layer’s attention log, keyed by file, version and offset. A read uses those same keys, so attention copies the text back exactly token by token.

0:30
satyam avatar
⟳ Nishkarsh retweeted
satyam@satyamsharma_33·Nov 2

Raft and Paxos aren't the only ways to prevent split-brain in distributed databases. @hydra_db takes an interesting approach. Instead of running a separate consensus cluster for graph writes, it uses S3-compatible object storage for coordination. Here's how it works: 1. Rendezvous hashing picks the preferred writer. 2. An atomic CAS lease decides who can actually write. 3. SlateDB writer epochs and fencing stop old writers from committing. Now imagine Node A loses connectivity and Node B takes over. What if A comes back and still thinks it's the writer? Even if A holds an outdated lease, SlateDB fencing prevents it from committing stale writes. The interesting trade-off is that HydraDB avoids a separate consensus service in its graph-data path, but now relies on the object store's consistency guarantees. It's a different way of approaching a familiar distributed systems problem. And it raises an interesting question: how does this design behave under frequent failovers and heavy write contention? Source: github.com/hydra-db/hydradb/…