# Athena: Building a Local-First AI Change Intelligence & Release Engine

> Source: <https://dev.to/aaryanrwt/athena-building-a-local-first-ai-change-intelligence-release-engine-2kie>
> Published: 2026-10-16 21:19:16+00:00

*This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle](https://dev.to/challenges/hacktoberfest-week2-2026-10-12)*

**Athena** is an open-source, local-first **Git & AST change-intelligence engine and Model Context Protocol (MCP) server** built for the Hacktoberfest 2026 â€” Side Hustle Challenge. ðŸ›¡ï¸

Every developer and engineering team faces the same dread on release day:

I built Athena to turn raw Git history and multi-language syntax trees into structured, mathematically verified change intelligenceâ€”without ever sending your code to closed third-party cloud APIs.

ðŸ” **AST-Level Breaking Change Detection**: Parses Python and TypeScript syntax trees across Git commit ranges to pinpoint removed exports, altered parameter lists (positional, keyword, and defaults), and modified return types.

ðŸ’¥ **Caller Blast Radius Mapping**: Automatically traverses your repository to find every internal file, caller function, and imported symbol affected by a modified signature.

ðŸ“š **Documentation Drift Detection**: Cross-references modified code symbols against Markdown guides and docstrings to catch stale documentation before shipping.

ðŸ“ **Evidence-Grounded Release Notes**: Generates categorized changelogs where every bullet point is linked directly to exact commit hashes and file diffs.

ðŸ”Œ **Universal Model Context Protocol (MCP)**: Plugs natively into Claude Desktop, Cursor, Zed, or any AI coding assistant via standard JSON-RPC 2.0 stdio tools.

ðŸ”’ **Offline-First & Privacy-Focused**: Runs completely on your local machine using Ollama and open-weight models like `qwen2.5-coder:7b`. Your proprietary codebase never leaves your computer.

Athena is built for engineering teams, freelancers, and companies building in regulated environments:

**The Side Hustle Model**: An open-core CLI and MCP server for solo developers, paired with an automated GitHub Action bot ($19/month solo / $79/month team) that audits every Pull Request and posts blast-radius warnings directly in PR reviews.

Athena can inspect any local Git repository (pass `.` for your current directory, or a path to a project). You can also run `python examples/create_demo_repo.py` to generate an instant sandbox repo with sample commits, breaking changes, and documentation drift.

```
python -m athena breaking-changes . --base v1.0.0 --target v2.0.0
Found 1 breaking change requiring human review:

[CRITICAL] calculate_metrics (function)
  Location: src/core/calculator.py:42
  Change: Non-optional parameter 'weights' was added to public function
  Evidence: commit 4a8b21c: "feat: add weights support to metrics calculation"
  Suggested SemVer Bump: MAJOR
python -m athena analyze . --base v1.0.0 --target HEAD
Analysis Summary:
  â€¢ Commits analyzed: 12 commits between v1.0.0 and HEAD
  â€¢ Files modified: 8 (Python: 5, TypeScript: 2, Markdown: 1)
  â€¢ AST Symbol changes: 3 modified signatures, 1 deprecated export
  â€¢ Downstream callers affected: 4 internal callers identified
python -m athena release-notes . --base v1.0.0 --target v2.0.0 --version "v2.0.0"
# Release Notes â€” v2.0.0

## âš ï¸ Potential Breaking Changes
- `calculate_metrics`: Parameter `weights` added without a default value in `src/core/calculator.py` ([`4a8b21c`](commit:4a8b21c))

## ðŸš€ What's Changed
- Added async worker queue execution engine in `src/engine/worker.py` ([`7d9e10f`](commit:7d9e10f))
- Refactored export interfaces in TypeScript client ([`b12c40e`](commit:b12c40e))

## ðŸ“š Documentation Drift
- `docs/api_guide.md` references the old 2-argument signature for `calculate_metrics`
```

Add Athena to your `claude_desktop_config.json` or Cursor settings:

```
{
  "mcpServers": {
    "athena": {
      "command": "python",
      "args": ["-m", "athena", "mcp"]
    }
  }
}
```

Now your AI editor can directly query Athena for verified blast radiuses and breaking-change assessments before suggesting code edits!

The entire engine is open-source under the MIT license:

`athena-mcp`)
**Local-First, Evidence-Backed Git & AST Release-Readiness and Change-Intelligence MCP Server**

Athena is an open-source, local-first Model Context Protocol (MCP) server and developer CLI that delivers **verifiable, ground-truth code-change intelligence**. By combining deterministic Git diff analysis, Python Abstract Syntax Tree (`ast`) and TypeScript/JavaScript structural signature comparison, downstream caller blast-radius tracing, and documentation-drift detection, Athena eliminates the hallucination and superficiality of conventional AI release-note generators.

`EvidenceRecord` items containing the 40-character commit SHA, commit subject, file path, exact base/target line spans, unified diff hunk…`/` markers, staticmethods, Windows NTFS stream protection, and TypeScript multiline interfaces)
Athena is engineered around a strict **hybrid architecture**:

```
[ Git History & Diff Engine ]
              â†“
  [ Multi-Language AST Parsers (Python + TypeScript) ]
              â†“
 [ Deterministic Verification & Blast Radius Engine ]
              â†“
     [ Ollama Local LLM (qwen2.5-coder:7b) ] (Optional Acceleration)
              â†“
   [ Standard MCP Server / CLI Output ]
```

Athena uses **[Ollama](https://ollama.com/)** with the open-weight **`qwen2.5-coder:7b`** model running locally on consumer hardware (tested on an NVIDIA RTX 4050 Laptop GPU with 6GB VRAM). The model synthesizes multi-commit diffs, grouping disparate changes into cohesive business narratives and technical release themes.

LLMs can invent code that does not exist. Athena solves this with a two-tier pipeline:

`ast` module and TypeScript syntax tokenizers. The breaking-change verdict is For a developer tool like Athena, **open innovation is the entire business enabler**:

ðŸ”’ **Client Privacy & Zero NDA Breaches**:

Freelancers and agencies handling enterprise code cannot send client intellectual property to OpenAI, Anthropic, or external cloud endpoints without written consent. Running open-weight models locally on the laptop guarantees 100% data sovereignty. Client code never leaves the machine.

ðŸ’° **Viable Unit Economics for a Side Hustle**:

Sending 50,000-line diffs across 20 pull requests a day to proprietary cloud APIs would rack up hundreds of dollars in token bills each month, destroying margin. With open-weight models running on consumer hardware, the marginal cost per audit is **$0.00**.

âœˆï¸ **Offline & Air-Gapped Autonomy**:

Developers code on flights, commuter trains, and secure air-gapped corporate intranets. Athena has zero network callsâ€”no telemetry, no internet checks, no cloud dependencies.

ðŸ”“ **No Vendor Lock-In**:

Because Athena is built on open standards (Git, standard ASTs, and the open Model Context Protocol), users can swap the local model from Qwen to Llama 3 or Gemma 2 at will.

To test Athena in a real-world setting, I shared it with a freelance backend developer who maintains a micro-service billing API for a retail client.

**The Test:**

We ran Athena against an upcoming `v2.0.0` refactor branch containing 38 commits.

**What Happened:**

Athena immediately flagged a **`CRITICAL` breaking change**: a helper method `format_tax_rate` had been changed into a `@staticmethod` and received a new positional argument without a default value. While the author's new unit tests passed, Athena's **Blast Radius** tool identified 3 legacy webhook processors in other files that were calling the old 1-argument signature. Merging that PR would have broken live customer invoice generation.

**Their Feedback:**

*"Catching that before the client saw it saved my reputation. In my freelance work, a broken webhook means angry emails and lost retainers. I'd easily pay $29 a month for a tool that automates this across my client repos."*

**What They Asked for Next:**

A native GitHub Action that automatically comments the blast radius report directly on pull requests.

Athena was developed using an AI-assisted engineering methodology, pairing iterative code generation with rigorous verification. You can review and inspect the full architecture, AST visitors, and test suite directly in the open-source repository.

`qwen2.5-coder:7b`) via Ollama with deterministic AST static analysis to deliver verifiable, private developer tooling.
