Inspiration
Modern software teams have powerful coding assistants, but they still struggle with one critical question:
"If I change this, what else will break?"
Code lives in one world. Metadata lives in another. Ownership, pipelines, dashboards, and business context are often disconnected.
We realized that no existing tool reasons across these worlds before a risky production change.
LynkPlanner was inspired by a simple idea:
Merge the code graph from LynkMesh with the metadata graph from DataHub into one Unified Graph, then let AI generate implementation plans grounded in deterministic evidence instead of guesses.
What it does
LynkPlanner analyzes a proposed engineering change (for example, deleting a legacy service) and produces an executable implementation plan backed by evidence from both the source code and metadata.
Instead of answering:
"I think this might work..."
it answers:
- what will break
- which database tables are affected
- which pipelines stop working
- which executive dashboards become inaccurate
- who must approve the change
- how to execute the migration safely
- how every recommendation is supported by graph evidence
The result is an AI Staff Engineer capable of reasoning across technical and business dependencies.
How we built it
LynkPlanner combines several components into a single reasoning pipeline.
- LynkMesh generates a deterministic code graph.
- DataHub provides metadata about datasets, lineage, dashboards, pipelines, and ownership.
- A Cross-Link Builder connects software entities with business assets.
- These are merged into a Unified Graph spanning code, metadata, and organizational knowledge.
- Deterministic graph traversal extracts evidence chains.
- An LLM uses only this grounded evidence to generate an implementation plan.
The system intentionally separates deterministic graph reasoning from natural language generation to minimize hallucinations.
Challenges we ran into
The biggest challenge was not generating text.
It was building reliable cross-domain relationships.
Code dependencies, metadata lineage, and organizational ownership all have different identifiers and different structures.
Creating a unified graph that could answer engineering questions consistently required designing a normalization layer, evidence propagation, and deterministic graph traversal.
Another challenge was ensuring every recommendation remained explainable rather than becoming a black-box AI output.
Accomplishments that we're proud of
- Built a Unified Graph spanning software architecture and metadata.
- Generated implementation plans supported by deterministic evidence.
- Produced traceable evidence chains from source code to executive dashboards.
- Clearly separated graph reasoning from LLM generation.
- Created a practical workflow that engineering teams could use before production changes.
What we learned
We started by thinking the hard problem was AI planning.
It wasn't.
The real challenge was building trustworthy context.
Once the relationships between code, metadata, lineage, ownership, and business assets were represented in a single graph, planning became dramatically more reliable.
We also learned that explainability matters more than perfect AI responses when engineers are making production decisions.
What's next for LynkPlanner
Our next goal is to evolve LynkPlanner from a planning assistant into an autonomous engineering agent.
Future work includes:
- Live DataHub integration through MCP
- Incremental graph updates
- Pull request impact analysis
- Automatic change validation
- Suggested implementation patches
- Risk scoring using historical production changes
- Multi-repository enterprise support
Our long-term vision is an AI Staff Engineer that helps organizations answer one question with confidence:
"Can we safely change this?"
Log in or sign up for Devpost to join the conversation.