Forem: Shivam Singh

Markarai - Agentic Ai Code Intelligence Platform-AI that understands your entire codebase

Shivam Singh — Sun, 10 May 2026 23:35:42 +0000

How We Built an AI That Understands Your Entire Codebase

When we started Markar, we asked a simple question:

"What if your codebase had an AI brain that understood every line of code,

every function relationship, and every dependency at scale?"

Most teams treat code like a black box. They don't really understand what

happens when they change something. Dependencies are invisible. Impact is unpredictable.

We built Markar differently.

Instead of just analyzing code statically, we created a living knowledge graph

of your entire repository. Every function, class, and dependency becomes a node.

Every relationship becomes an edge. The graph learns, updates in real-time, and

powers autonomous AI agents that help you write better code.

Think of it like giving your engineering team a senior architect who has read

every line of code you've ever written, understands all the patterns, knows all

the pitfalls, and can predict the impact of any change before you even make it.

Here's what Markar actually does:

🧠 INTELLIGENT CODE UNDERSTANDING

We parse your entire repository using advanced AST analysis. Unlike traditional

linters that look at syntax, Markar builds a semantic understanding - it knows

which functions call which, what each function does, what the risks are, and how

everything connects together. A 196K line codebase becomes 9,219 interconnected nodes

that our AI can reason about.

🤖 AUTONOMOUS AGENTS THAT ACTUALLY HELP

This is where Markar gets interesting. We've built multiple AI agents that operate

on top of this knowledge graph:

• CODE REVIEW AGENT: Reads your PR and understands the context. Not just syntax -

it knows what the code is trying to do, sees the potential bugs, checks against

your existing patterns, and flags real issues (not false positives).

• IMPACT ANALYSIS AGENT: Before you merge anything, this agent traverses your

dependency graph and tells you exactly what will be affected. It shows you functions

that will break, files that need testing, and the ripple effect of your change.

• QA AGENT: Generates meaningful tests automatically. It doesn't just create boilerplate -

it understands your code patterns and creates tests that actually catch real bugs.

• CUSTOM AGENT FACTORY: You can describe what you need ("Find all authentication

vulnerabilities") and Markar creates an agent that does exactly that. No coding needed.

• SECURITY AGENT: Scans for common vulnerabilities but with context. It knows your

codebase, your patterns, your architecture - so it finds real security issues in

your specific context, not generic ones.

⚡ REAL-TIME KNOWLEDGE GRAPH

The magic is that this isn't static. Every commit, every push updates the graph.

Your AI agents always know the current state of your codebase. They're never working

with stale information.

🔍 WHAT MAKES THIS DIFFERENT

Most tools do code analysis. Some do static checking. A few do test generation.

Markar combines all of this AND adds autonomous agents on top. It's not just

telling you "here's a problem" - it's actively helping you understand, test,

and improve your code.

And crucially: it understands relationships. The difference between knowing that

a function exists and knowing that 47 other functions depend on it is everything.

💡 WHY THIS MATTERS

For new team members: Instead of spending 3 months understanding the codebase,

they can ask Markar questions on day 1 and get accurate answers.

For refactoring: Before touching legacy code, you can see all the impact upfront.

No surprises in production.

For code reviews: Your team moves faster because the AI catches the issues that

humans miss - the cross-module dependencies, the subtle edge cases, the patterns

that don't match your architecture.

For scaling: As your team grows, you don't lose velocity. Markar scales with you.

🚀 WHERE WE ARE

Markar is live and being used by 20+ companies across different industries -

from early-stage startups to established enterprises. We're seeing:

• New dev onboarding cut from 3 months to 2 weeks

• 40% reduction in production bugs

• 2x faster release velocity

• Teams shipping features with 10x more confidence

This is just the beginning.

The future of software engineering isn't just better tools for writing code.

It's AI that understands your code deeply, predicts problems before they happen,

and helps your team move faster without cutting corners on quality.

That's what Markar is building.

If you're an engineering leader dealing with:

• Large, complex codebases that are hard to navigate

• New hires taking forever to become productive

• Code reviews that miss critical issues

• Refactoring that feels too risky

• Technical debt you can't measure or manage

Markar is built for you.

We're onboarding early customers now.

What would your team do with a senior architect who understands every line

of your code and never sleeps?

Let's talk. #markarai #agenticAI

Markarai Agentic AI Code Intelligence Platform: The AI That Understands Your Entire Codebase

Shivam Singh — Sun, 10 May 2026 23:31:03 +0000

🧠 Building an AI That Understands Your Entire Codebase (Technical Deep-Dive)

When you have a 100K+ line codebase, understanding it is hard.

Not just reading the code - but really understanding it. Knowing which functions
call which. Knowing what happens when you change something. Knowing the invisible
dependencies that will break your code.

We built Markar to solve this.

The Problem We Solved

Traditional code analysis tools are stateless. They look at a file in isolation.
They find syntax errors, style violations, basic security issues. But they don't
understand your code's structure, its relationships, or how it all fits together.

Result: You push code, tests pass locally, and then something breaks in production
because you didn't realize function A calls function B which calls function C across
4 different services.

Our Approach: Knowledge Graphs + AI Agents

Instead of static analysis, we built a living knowledge graph of your codebase.

Here's how it works:

Code Parsing: We parse your entire repo using advanced AST analysis.
Every function, class, method, import becomes a node.
Dependency Mapping: We build edges between nodes. Function A calls Function B.
Class X extends Class Y. Service A uses Library B. Everything gets connected.
Real-time Updates: When code changes, the graph updates. No staleness.
Always accurate.
Agent Layer: On top of this graph, we run autonomous AI agents that reason
about your code at scale.

What Agents Can Do

Once you have a knowledge graph, you can build agents that actually understand context:

Impact Analysis Agent:

User asks: "What happens if I change the payment function?"

Agent:

Finds the payment function in the graph
Traverses all outgoing edges (what does it call?)
Traverses all incoming edges (what calls it?)
Builds a dependency tree 3-4 levels deep
Identifies all affected files, functions, services
Estimates risk level based on criticality
Recommends tests to run

Code Review Agent:

PR comes in with 20 files changed.

Agent:

Reads the changes in context of the knowledge graph
Checks: "Is this function called 47 times? Should we be careful?"
Checks: "This change touches 3 services. Are they tested?"
Checks: "This violates the pattern we see in other parts of code"
Checks: "This could cause a race condition in this scenario"
Provides specific, context-aware feedback

QA Agent:

Function gets added to codebase.

Agent:

Understands what the function does
Generates test cases based on:
Input/output types
Edge cases
Patterns from similar functions in codebase
Known failure modes in your architecture
Runs the tests
Reports coverage

Why This Matters

Most code analysis tools give you a list of issues. Markar gives you understanding.

The difference is like:

Tool: "Line 47 has a potential null pointer"
Markar: "Line 47 could crash because this function is called by 3 other critical services in production when X happens under load"

Context changes everything.

Real Numbers

We tested Markar on several open-source codebases:

repo (their own codebase): 1098 files, 196K lines → 9219 nodes,
0 circular dependencies detected, 40 high-risk files identified
Average impact analysis: 50ms query time for dependency traversal
(vs 5+ seconds for manual code review)
Test generation: 25 meaningful tests generated per new function
(vs 5-10 manually written)

The Architecture

Code Repository ↓ AST Parser (Python, JS, Go, Rust) ↓ Knowledge Graph (Neo4j) ↓ Agent Layer (LLM + Graph Reasoning) ↓ Insights (Impact, Tests, Reviews, Security)

What's Next

We're currently working on:

Multi-language support expansion
Self-learning agents that improve over time
Architecture recommendation engine
Automated refactoring suggestions
Technical debt quantification

Open Questions We're Solving

How do you make AI understand code context without hallucinating?
→ Answer: Graph-grounded reasoning. The AI only knows what's in the graph.
How do you scale this to 1M+ line codebases?
→ Answer: Incremental updates, smart caching, distributed graph queries.
How do you make this actually useful vs theoretical?
→ Answer: Focus on practical problems - impact analysis, test generation, reviews.

If you're building developer tools, or just interested in AI + code understanding,
I'd love to hear your thoughts.

What's the hardest part about working with large codebases in your team?