SourceAnt
EN

Software-Intelligenz für Sie und Ihre Coding-Agenten.

SourceAnt verbindet Ihren Code, die Dienste, von denen er abhängt, und die Entscheidungen dahinter. Bringen Sie diesen Kontext in die Arbeit Ihrer Agenten und Ihre Code-Reviews ein, damit die nächste Änderung auf dem aufbaut, was Ihr Team bereits weiß.

Erste Schritte In Aktion erleben

Ab 49 $ pro Monat, niemals pro Nutzerlizenz · Jeder Engineer und jeder Agent inklusive · Ihre eigenen Modellschlüssel · On-Premise verfügbar

Woraus Ihr System tatsächlich besteht

Die aus Ihrem Code ausgelesenen Bestandteile, dann dasselbe System als Diagramm: was was bereitstellt und was wovon abhängt.

Systeme erkunden

Ein Beispiel: Änderung der Zahlungswiederholungen

Eine Entscheidung erinnert. Ein Konflikt erkannt.

  1. 1. Die Entscheidung beibehalten

    Der mobile Client besitzt den Zahlungsschlüssel.

    Begründung festhalten: Die Wiederverwendung desselben Schlüssels ermöglicht eine Zahlungswiederholung, ohne eine zweite Belastung zu erzeugen.

  2. 2. Den Code verbinden

    Der Client und der Zahlungsdienst teilen diesen Vertrag.

    Verknüpfen Sie die Entscheidung mit beiden Seiten, auch wenn sie in getrennten Repositories liegen.

  3. 3. Mit diesem Wissen prüfen

    Ein neuer Schlüssel bei jeder Wiederholung bricht die Vereinbarung.

    Der Review kann auf die aufgezeichnete Entscheidung und den betroffenen Client verweisen, damit der Autor weiß, was zu bewahren ist.

Ein Team von zehn Engineers zahlt $49, nicht 240 $ bis 300 $ Agent-nativ, über MCP Ihre eigenen Modellschlüssel Menschlich gesteuertes Wissen
curl -fsSL https://raw.githubusercontent.com/sourceant/cli/main/scripts/install.sh | sh

Die tägliche Realität

KI hat das Schreiben von Code billig und das Vertrauen darin teuer gemacht.

In einer großen, kritischen Codebasis überholt die Geschwindigkeit heute die Fähigkeit jedes Einzelnen, die Architektur im Kopf zu behalten, eine Änderung am realen System zu beurteilen und sie sicher auszuliefern.

  • Das Warum lebt in den Köpfen Ihres Teams

    Agenten erzeugen an einem Tag mehr Änderungen, als Ihre Senior-Entwickler bis zu den dahinterliegenden Entscheidungen zurückverfolgen können. Die Begründung, die das System korrekt hält, hat es nie aus einem Slack-Thread oder einem geschlossenen PR herausgeschafft.

  • Das System wächst über jeden Überblick hinaus und driftet unbemerkt ab

    Es wird größer und mehr KI wirkt darauf ein, bis niemand mehr die Gesamtform im Griff hat. Es verändert sich ständig in eine Richtung, die niemand bewusst gewählt hat, und Sie bemerken es erst, wenn es schwer rückgängig zu machen ist.

  • Qualität und Zuverlässigkeit sinken, während Sie KI skalieren

    Je mehr Sie mit Agenten ausliefern, desto mehr Workarounds werden zurückgenommen, Konventionen driften ab und Verträge brechen. Das Vertrauen in die Codebasis erodiert genau dann, wenn Sie am schnellsten unterwegs sind.

  • Ihre KI-Ausgaben steigen und der Kontext bleibt nie erhalten

    Jede Sitzung erklärt dieselbe Architektur erneut, verbrennt Tokens und Pro-Sitzplatz-Gebühren, und nichts davon wird für die nächste Entwicklerin oder den nächsten Agenten festgehalten.

Teams, die das Warum festhalten, multiplizieren Verständnis mit jeder Änderung. Teams, die das nicht tun, liefern schneller in ein System, das sie jede Woche weniger verstehen.

Die These

Ein Code-Graph sagt einem Agenten, was der Code ist. Nicht, wofür er da ist.

Indizieren Sie ein Repository, und Sie können beantworten, wo ein Symbol liegt, wer es aufruft und was es importiert. Das ist ein gelöstes Problem, und wir haben es nicht neu erfunden: der Code-Graph unter SourceAnt ist codebase-memory-mcp, auf dem wir aufbauen.

Es reicht auch nicht aus, um eine korrekte Entscheidung zu treffen. Struktur kann einem Agenten nicht sagen, dass die Retry-Obergrenze nach einem Vorfall festgelegt wurde, dass ein Service zwei Repositories entfernt den Vertrag konsumiert, den er gerade bearbeitet, oder dass die Regulierungsbehörde den naheliegenden Ansatz im letzten Quartal ausgeschlossen hat. Nichts davon steht im Code, also kann kein Parser es finden.

Alles über dem Graphen ist der Teil, den wir bauen mussten.

Was der Code ist

Dateien, Symbole, Aufrufe und Importe. Basiert auf codebase-memory-mcp, das dies gut und offen macht.

Wofür es gedacht ist

Die Entscheidungen, Einschränkungen und Konventionen, die Ihr Team festgehalten hat, und die organisatorischen Regeln, die nie in einer Datei standen.

Womit es verbunden ist

Die Services, Queues und Datastores auf der anderen Seite der Änderung, über Repositories hinweg, die ein einzelner Diff nicht sehen kann.

Ob es noch gilt

Ein Status, den Ihr Team kontrolliert, und eine Veraltungsmarkierung, damit eine überholte Regel nicht mehr als aktuelle ausgegeben wird.

Eine Plattform

Eine Wissensschicht, viele Aufgaben darauf

SourceAnt erfasst, wie Ihre Codebasis funktioniert, und stellt es überall bereit, damit Ihre Tools und Ihr Team auf echtem Verständnis handeln, statt Dateien zu überfliegen.

Code-Graph

Eine Karte Ihrer Dateien, Symbole und ihrer Beziehungen. Sehen Sie die Struktur, die ein Agent ändert, nicht nur die Zeilen in seinem Diff.

Wissensgraph

Was Sie über den Code wissen oder wissen sollten. Behalten Sie Entscheidungen, Einschränkungen und Konventionen, nachdem die Sitzung, die sie gefunden hat, endet.

Systemgraph

Lebendige Architekturdokumentation. Sehen Sie, wie Services und Datastores verbunden sind, wohin sich die Architektur bewegt und ob Sie wollen, dass es dorthin geht.

Anforderungsgraph

Was die Software tun soll, verknüpft mit dem Code und den Tests, die es tragen. Premium-Anforderungsengineering baut auf der lokalen Grundlage auf.

Das ganze System

Erfassen Sie das Wissen einmal. Setzen Sie es überall ein.

Eine lebendige Karte, wie Ihr System funktioniert: Ihr Team sieht, wohin es steuert, und lenkt es, Ihre Agenten bauen mit dem vollständigen Kontext, und die Aufgaben, auf die Sie sich verlassen, laufen darauf.

Code-Wissensmanagement

Verstehen Sie Ihr eigenes System und halten Sie Ihre Agenten darauf

SourceAnt erfasst die Entscheidungen, Einschränkungen, Verträge und Konventionen hinter Ihrem Code und strukturiert sie zu einer lebendigen Karte, wie Ihr System tatsächlich funktioniert, eine, die aktuell bleibt, während sich der Code ändert.

Für Ihr Team

Sehen Sie, wie das System aufgebaut ist, wie es sich verändert und wohin es steuert, damit Sie Drift früh erkennen und entscheiden, ob das die Richtung ist, die Sie wollen, bevor sie sich festsetzt.

Für Ihre Agenten

Der relevante Ausschnitt wird über MCP zurückgegeben, sobald ein Agent handelt, sodass er mit dem vollständigen Warum baut, statt es zu erraten.

Kontextbewusste Überprüfung

Prüfen Sie jede Änderung gegen Ihre echten Entscheidungen und ihren Blast-Radius, damit die Bugs, die gut aussehen, und die Workarounds, die sie löschen will, vor dem Merge markiert werden.

Issue-Triage

Duplikaterkennung und intelligente automatische Kennzeichnung bei Issues und PRs, damit Ihr Backlog dedupliziert und geroutet bleibt, ohne manuelles Sortieren.

Engineering-Analytik

Sehen Sie Token-Nutzung und Einsparungen, Review-Qualität, Kontextabdeckung und Triage-Statistiken, damit Sie Zuverlässigkeit und KI-Ausgaben beim Skalieren im Blick behalten.

Portabel

Funktioniert mit den Tools, die Sie bereits nutzen

SourceAnt spricht MCP, sodass Ihr Kontext und jede Anwendung in dem erscheinen, womit Ihr Team codiert. Und es ist nicht nur für Menschen: Agenten fragen das Wissen headless mitten in der Aufgabe ab, ohne dass jemand Kontext erneut einfügt. Kein Lock-in, keine neuen Gewohnheiten.

Claude Code
Cursor
Codex
Zed
VS Code
Jeder MCP-Client
SourceAnt über MCP

Bringen Sie SourceAnt in die Aufgabe, an der Sie arbeiten

/sourceant

  • /sourceant:contextLesen Sie den indexierten Graphen und die zu einem Repository erfassten Entscheidungen, statt sie per grep zu suchen.
  • /sourceant:rememberErfassen Sie eine Entscheidung, Konvention oder Einschränkung, damit sowohl die nächste Sitzung als auch das nächste Review davon wissen.
  • /sourceant:use_skillWenden Sie einen benannten Skill auf eine Aufgabe an, optional aus einem Repository.
  • /sourceant:choose_skillFinden Sie einen relevanten Skill und wählen Sie aus, welche Anweisungen angewendet werden sollen.
  1. Kontext lesenDen indexierten Graphen und erfasste Entscheidungen anfordern.
  2. Entscheidung behaltenEine Konvention oder Einschränkung für spätere Arbeit erfassen.
  3. Skill verwendenAnweisungen auswählen, die auf die aktuelle Aufgabe angewendet werden sollen.

Wird in Claude Code angezeigt. Prompt-Namen hängen von der Verbindung und den verfügbaren Skills ab.

Für wen es ist

Für Teams, die mit KI schnell an Code ausliefern, der nicht brechen darf

Sie betreiben eine große, kritische Codebasis, bewegen sich im Tempo Ihrer Agenten und legen ebenso viel Wert auf Architektur und Zuverlässigkeit wie auf Geschwindigkeit. Sie hosten selbst, wünschen nutzungsbasierte Preisgestaltung und eigene Schlüssel, und Sie brauchen Menschen, die das System weiterhin verstehen, nicht nur den Code.

Der Architekt, der das Warum bewahrt

Sie sind der Grund, warum das System noch zusammenhält. SourceAnt holt Entscheidungen, Einschränkungen und Verträge aus Ihrem Kopf in einen Graphen, den jedes Tool und jeder Teammate abfragen kann, damit die Architektur das Tempo übersteht, mit dem Sie ausliefern.

Der Plattform-Lead, der selbst hostet

Sie betreiben das auf Ihrer eigenen Infrastruktur, mit Ihren eigenen Keys, und Sie behalten die KI-Rechnung im Blick. SourceAnt ist Open Source, bepreist nach dem, was es analysiert, statt nach Nutzerlizenzenn, und standardmäßig privat, und es reduziert Tokens, indem es nur das Teilstück liefert, das eine Aufgabe benötigt.

Der Ingenieur, der geradesteht

Sie sind verantwortlich, wenn die Änderung eines Agenten die Produktion bricht. SourceAnt beurteilt jede Änderung gegen das reale System und übergibt Ihren Tools die Begründung hinter dem Code, damit Geschwindigkeit Sie nicht Ihr Vertrauen kostet.

So funktioniert es

Ein Graph, kein Textstapel

Erfassen Sie das Warum, verknüpfen Sie es zu einem Wissensgraphen und liefern Sie nur das relevante Teilstück an jedes KI-Tool in dem Moment, in dem es handelt.

1. Den Code kartieren

Indexieren Sie Ihre Repositories in einen Code-Graphen, damit Sie und Ihre Agenten Symbole und Beziehungen über den geänderten Code hinweg verfolgen können.

2. Ihre Absicht bewahren

Halten Sie die Entscheidungen, Einschränkungen und Anforderungen fest, die die Software weiterhin respektieren muss. Verknüpfen Sie sie mit dem Code und den Systemteilen, für die sie gelten.

3. Vor jeder Änderung nutzen

Geben Sie den relevanten Kontext über MCP an Ihre Tools und reviewen Sie Agentenänderungen, bevor sie Ihre Kollegen erreichen.

Dateien, verknüpft mit den Entscheidungen und Konventionen, die sie erklären

In der Praxis

Die Entscheidungen, die Ihr Agent sonst rückgängig machen würde

Ein Assistent liest den Code vor sich. Er kann nicht den Vorfall lesen, der das Retry-Limit festgelegt hat, oder die Diskussion, die Jitter ausgeschlossen hat. SourceAnt übergibt ihm beides, bevor es schreibt.

Ein Assistent wird gefragt

Refaktoriere die Zahlungs-Retry-Logik auf exponentielles Backoff.

src/payments/retry.ts

SourceAnt antwortet mit dem, was dieser Code bereits entschieden hat

Constraint aus einer Incident-Review

Max. Retries bleiben bei 3. Höhere Werte haben bereits einmal doppelte Abbuchungen verursacht.

Entscheidung aus einer Teambesprechung

Jittered Backoff hat den Rate Limiter nicht überlebt. Die feste Verzögerung ist beabsichtigt.

Vertrag vom mobilen Client

Idempotenzschlüssel werden clientseitig generiert. Eine Änderung daran bricht die mobile App.

Es liefert den Backoff aus und lässt die Retry-Obergrenze, die feste Verzögerung und den Idempotenzschlüssel unverändert.

Bereitgestellt über MCP, sodass dies in dem Assistenten funktioniert, den Ihr Team bereits verwendet.

Veranschaulichendes Beispiel

Die andere Richtung

Die Sitzung endet. Was sie Ihnen beigebracht hat, muss es nicht.

Das meiste, was ein System korrekt hält, wird mitten in der Aufgabe erarbeitet und dann verloren, wenn das Fenster sich schließt. SourceAnt gibt Ihrem Agenten einen Ort dafür, über MCP, in dem Tool, in dem Sie sich bereits befinden.

/remember

Speichern Sie, was Sie gerade erarbeitet haben

Sie finden heraus, warum die feste Verzögerung beabsichtigt ist. Ein Befehl, und sie ist eine Einschränkung für diesen Code, verfügbar für die nächste Sitzung und den nächsten Entwickler.

/context

Fragen Sie, was dieser Code bereits entschieden hat

Bevor Sie eine Datei anfassen, rufen Sie die Entscheidungen, Einschränkungen und Verträge ab, die sie regeln, statt die Absicht aus den Zeilen vor Ihnen abzuleiten.

/review

Lassen Sie sich prüfen, bevor Sie pushen

Prüfen Sie die Arbeit in Ihrem Checkout, uncommitted und ungepusht, gegen denselben Graphen, nach dem ein Pull Request beurteilt würde.

Es geht nicht nur um Code. Eine Regel, was niemals in ein Analytics-Event gelangen darf, eine Einschränkung, die eine Aufsichtsbehörde Ihnen auferlegt hat, eine Konvention, auf die sich zwei Teams in einem Meeting verständigt haben: Nichts davon steht in einer Datei, also hat ein Tool, das Dateien parst, keinen Ort dafür. Ein Wissenseintrag hier hat kein Repository-Feld und kein Datei-Feld, und genau das ermöglicht es ihm, die Dinge zu halten, die Ihre Codebasis nie aufgeschrieben hat.

Systeme & repositoryübergreifende Reviews

Woher das Review weiß, dass Ihr Frontend kurz vor dem Bruch steht

SourceAnt liest die Manifeste, die Ihre Repositories bereits veröffentlichen, schlägt vor, wie die Teile voneinander abhängen, und wartet auf die Freigabe durch eine Person. Diese Karte ist es, die ein Review durchläuft: Ändern Sie hier einen Vertrag, und es geht dorthin und liest den Dienst, der ihn dort drüben konsumiert. Wenn ein Teil nicht mehr zum Code passt, wird er als veraltet markiert, statt stillschweigend falsch zu bleiben.

Ein Repository, das nicht gelesen werden konnte, wird benannt, nicht übersprungen.

Jeder Vorschlag ist ausstehend. Nichts hier genehmigt sich selbst.

Jede Kante nennt die Datei, aus der sie gelesen wurde.

Ein Teil, der gealtert ist, wird gekennzeichnet, nicht stillschweigend geglaubt.

So funktioniert repositoryübergreifendes Review Anwendungsfälle ansehen
Ein Softwaresystem in SourceAnt, das seine Dienste, Datenspeicher und die Beziehungen zwischen ihnen zeigt, mit ausstehenden Vorschlägen, die auf Freigabe warten

Warum SourceAnt

Warum nicht Kommentare, ADRs, eine Vektordatenbank oder ein weiterer Review-Bot pro Nutzerlizenzplatz?

Strukturiert, nicht Prosa. Kontext ist typisiert und in einem Graphen verknüpft, sodass Tools genau das richtige Segment abrufen, statt veraltete Kommentare zu durchsuchen.

Gesteuert, nicht halluziniert. Wissen trägt einen Status, den Ihr Team kontrolliert und nach dem Ihre Tools filtern: Freigabe kennzeichnet, wofür das Team bürgt, und sie stellt die Erfassung nie hinter eine Person an. Ein Vektorspeicher rät nur.

Portabel und privat. Über MCP für jedes Tool bereitgestellt, Open Source, das Sie selbst hosten können, mit Ihren eigenen Modellschlüsseln. Ihr Wissen und Ihre KI-Ausgaben bleiben auf Ihrer Seite, niemals in einem Anbieter-Silo.

Bepreist für die Art, wie Sie tatsächlich arbeiten. Nutzungsbasiert und mit eigenen Schlüsseln, ein Preis für das gesamte Team, keine KI-Steuer pro Nutzerlizenzplatz, wenn Sie Entwickler oder Agenten hinzufügen.

Wie SourceAnt im Vergleich zu Sourcegraph und graphify abschneidet

Prüfen Sie das ganze System, nicht einen einzelnen Diff

Ab 49 $ pro Monat, mit Ihren eigenen Modellschlüsseln. Jeder Entwickler und jeder Agent, den Sie haben, zum selben Preis. On-Premise, wenn Ihr Code Ihr Netzwerk nicht verlassen darf.

1. Verbinden Sie Ihre Repos 2. Genehmigen Sie, was erfasst wird 3. Alle liefern mit dem Warum aus
Kostenlos starten Lesen Sie die Dokumentation