I asked ZAUTH to scan my open-source project EKOS. Result: 73/100 — with no external code matches and no critical security vulnerabilities found. What I'm most proud of isn't the score. It's the engineering behind it: • Rust-based knowledge compiler • Custom fact ledger + indexing • SQL analysis across multiple dialects • Pentaho/Informatica transformation recovery • Cross-system identity resolution • 126 commits in 43 days EKOS is also connected to the $EKOS token — but the token is not the point. The point is building something real, open-source, technically ambitious, and useful for engineers dealing with legacy systems + AI. I'm building in public. 🔗 ZAUTH: zauth.inc/reposcan/scan/scan… 🔗 GitHub: github.com/alexeyban/EKOS/ $EKOS #Rust #OpenSource #DataEngineering #AI

Every morning, I wake up hoping that today will be the day EKOS takes off and goes to the moon. 🚀 Then I check the stats, see that it hasn't happened yet, grab my coffee, and get back to work. And you know what? I still believe in this project. It reminds me of Thomas Edison and the light bulb. The popular story says he failed a thousand times before finding success. Whether the exact number is true or not, the lesson remains the same: persistence matters. I'm not going to give up on EKOS just because success takes longer than expected. I'll keep building, improving, and pushing the project forward. Maybe it won't happen overnight. Maybe it will take months or even years. But I believe that if we keep creating real value, the long-term results can follow. Whether you choose to stay with EKOS or walk away is entirely up to you. I respect that. I'm just asking for one thing: patience. Great things rarely happen on our preferred timeline. Building something meaningful takes time, and only time will tell where this journey leads. History will be the judge. Until then, I'll keep building. 🛠️🚀 Still here. Still building. Still believing. — Alexey

Good idea from a recent discussion: integrate EKOS with LinkML. EKOS already keeps every fact with evidence: file, line, commit, confidence. The missing piece is turning that into a formal semantic layer. Next iteration: - recover business concepts from SQL, ETL and git history - export them to LinkML as drafts with evidence flag conflicts and gaps - a human confirms, LinkML tooling does the rest (WEB UI) EKOS finds the meaning. LinkML stores and shares it. Building it next. Will share results, including what doesn't work.

Your AI agent’s memory shouldn’t be locked to one app, model, or runtime. Walrus Memory gives agents portable memory across the tools and workflows they run in.

x.com/ekosproject/status/210… Or, share and live ...

Everyone's asking whether AI will write their SQL. Wrong question. SQL was never the hard part. The hard part was knowing the legacy system: which DDL is actually deployed, what a negative number means in the ledger, and whether your marts match Finance to the cent. That knowledge used to live in one engineer's head. I compiled it with EKOS and let an agent migrate a real ERP to ClickHouse + dbt. Every step is logged, and risky changes go to a human. AI won't replace the engineer who defines "correct." It will replace the one whose only moat was "I'm the only one who knows how this works."

HBD TO ME ….🎂🎉🥳 we are building best future for agents 🫂🤝🔥 @ekosproject $EKOS

Yup

I gave Claude Code one brief and access to EKOS, my open-source knowledge compiler. Then I stayed out of the engineering. The brief: take LedgerSMB, a real open-source ERP (Perl + PostgreSQL, 168 tables, 504 stored functions), migrate it to ClickHouse, and build finance and materials reporting in dbt. Every number had to be provable, not just produced. What came back is a new repo, built from scratch: → LedgerSMB rebuilt from its own SQL tree: 175 change scripts, 0 failures → 18 months of a synthetic distributor, posted through LedgerSMB's own stored procedures, so the ERP computes FIFO COGS itself → EKOS compiled the LedgerSMB codebase (11,084 objects) and answered 305 design questions, each cited to file and line → EKOS Migrate ran drift, PII suppression, 674 findings, type mapping, risk gates, load and 3-tier validation: 30/30 tables pass → dbt: 38 models, 124 tests, 162/162 green → Reconciled against LedgerSMB's own reports: 6/6, to the cent → One command rebuilds everything from an empty database in about 6 minutes The part I care about most is that the agent refused to trust green. It planted a defect at every level of checks. A single +0.01 on one journal line passed row counts and column stats, and the row-hash tier caught it. Before a fix, that tier hashed unconstrained numerics at scale 0. It could not see cents, and it still reported "pass." It found 16 defects in EKOS itself, 4 of them critical, including a way for a requester to approve their own high-risk load. All are fixed, each with a regression test. The one human step was by design. EKOS requires human approval for high-risk loads, and all 8 of the agent's self-approval attempts were refused. It's also honest about what isn't done. EKOS's own migration report says "Not signable," because the disposition workflow doesn't exist yet. Open issues are listed in the deck, and every LLM call is logged with tokens per model. Checked, not trusted. Full 50-slide walkthrough: lnkd.in/dvE8cQ7c Generated repo: lnkd.in/drcaK_WH #DataEngineering #ClickHouse #dbt #AIAgents #ClaudeCode #DataMigration #OpenSource

Why EKOS ? What is @ekosproject EKOS is an open-source knowledge infrastructure designed to turn complex technical and operational data into structured, traceable, and reusable knowledge for AI systems. Instead of treating source data, execution history, and agent context as disposable inputs, EKOS preserves where knowledge came from, how it was derived, what evidence supports it, and how it changes over time. EKOS can ingest software repositories, SQL, legacy ETL, Git history, documentation, and other enterprise sources, then compile them into a versioned Canonical Knowledge Model backed by an append-only evidence ledger. On top of that foundation, EKOS provides a read-only MCP layer and a Web Console for exploring the resulting knowledge, provenance, relationships, evidence, and system health. The goal is simple: compile knowledge once, preserve the evidence behind it, and make it reusable across future agents, workflows, and systems. The project is also moving toward letting teams connect their own data and test EKOS with their own agents and workflows, making the knowledge layer useful beyond a single application or session. Products and capabilities currently presented by EKOS include: • EKOS Knowledge Compiler — converts code, SQL, ETL, Git history, and documentation into structured knowledge. • Canonical Knowledge Model — a normalized representation of entities, relationships, dependencies, and technical knowledge. • Evidence-backed Append-only Ledger — preserves provenance, source evidence, versions, and changes instead of silently overwriting history. • Read-only MCP Interface — gives agents controlled access to compiled knowledge through MCP. • EKOS Web Console — visualizes the ledger, knowledge relationships, evidence, health, and project state. • Provenance & Evidence Layer — allows knowledge and relationships to be traced back to their original source and location. • Agent/Workflow Knowledge Layer — provides a foundation for turning execution history, decisions, failures, fixes, and verification results into reusable knowledge. • Own-data Testing — enables teams to connect their own data and evaluate how EKOS can support their agents and workflows. The broader vision is to move enterprise AI from simply retrieving information toward systems that can preserve, verify, and continuously reuse what they learn. EKOS: Compile once. Query forever. Build on verified knowledge. ekos.dev/

Great things take time and quiet focus. 🤫 Currently heads-down working on an exciting new feature for my project while actively pushing outreach on LinkedIn and sending proposals to companies. Building in silence, results incoming. 🚀

The next big AI narrative? 🚀💣 I think @ekosproject could get even hotter than Jev. 👀😎 Why? Because the next wave of AI isn't just about faster or cheaper models. It's about how AI builds, preserves, and reuses knowledge. @ekosproject is building around 3 core narratives: 1️⃣ Enterprise Knowledge Infrastructure Turning code, SQL, ETL, and documentation into a traceable, evidence-backed Knowledge Ledger. Enterprise knowledge shouldn't disappear across files, systems, and teams. 🧵📎 🔗 github.com/alexeyban/EKOS

Hey guys, kinda surprised this flew under the radar 🤷‍♂️ I took MarkdownSharp (the engine that powered Stack Overflow) as a compiled .NET DLL. No repo, no source, just bytes. EKOS decoded it into a statement-level spec: 99 of 101 methods fully recovered, every line tied to its IL offset. The 2 it couldn't fully structure, it flagged as partial and said "don't guess". Then an agent rewrote it in Python from that spec. Checked against the running original: → 15/15 fixtures, identical sha256 → 3,000 fuzzed documents, identical → I planted a one-flag regex bug, the fuzzer caught 44 diffs in 300 docs Why I care: in every big company, the real blocker isn't "which new platform". It's "nobody knows what this thing does and the source is gone". Once the logic is explicit and verifiable, the target is a detail. Python here, but the same approach applies to rebuilding logic on Spark, Databricks, Fabric. Every step with screenshots 👇 alexeyban.github.io/EKOS/pre… #EKOS #DataEngineering #databricks #fabric

Meet EKOS v1.0.0 🦀 Rust knowledge compiler: code, SQL, ETL and docs → one evidence-backed fact ledger. Every answer traces to file and line. 📦 Publishing to crates.io (MIT) 🚀 First VC pitches are out Solo founder, ~200 devlogs. github.com/alexeyban/EKOS #rustlang #EKOS

Bringing fragmented observations into one representation is a huge step. The next challenge is preserving the knowledge behind that representation — where each piece came from, what changed, and what evidence supports the conclusions.🧵📎

Every company has that one application nobody dares to touch. The source code is lost, or the people who wrote it left years ago. It still runs something important, so it stays. Rewriting it is risky because nobody can say, with proof, that the new version behaves the same. I wanted to test one answer to that problem, so I ran an experiment with EKOS, the open-source tool I'm building. The setup: a compiled .NET library with no source code, MarkdownSharp, the engine that powered Stack Overflow. We had only the compiled file. What happened: 1️⃣ EKOS read the binary without running it and recovered what the code does, statement by statement. Every statement points back to where in the binary it came from. 2️⃣ Where it couldn't recover the logic fully (2 of 101 methods), it said so and told the person porting not to guess. This matters more than it sounds. The dangerous failure in a migration is plausible-looking code that is silently wrong. 3️⃣ A Python rewrite was written from that recovered specification. 4️⃣ The original program was run in a sandbox, and its outputs were recorded as the reference. The result: the rewrite and the original produced identical output on all 15 test documents and on 3,000 generated ones. To be sure the test itself could fail, I deliberately broke the rewrite with a one-flag change. The test caught it: 44 differences in 300 documents. A code review would likely have missed it. The takeaway for decision makers: the hard part of modernizing legacy software isn't writing new code. It's knowing what the old code actually does, and proving the new one matches. EKOS doesn't write the port. It makes the starting point trustworthy and the finish line checkable. What this does not show: ▪️ It's one small, open-source library, not a production migration ▪️ Only .NET so far ▪️ The rewrite was written by an LLM, using EKOS's spec and checks ▪️ I did not compare it head-to-head against a plain LLM Every step is documented with screenshots, and you can rerun all of it: 🔗 alexeyban.github.io/EKOS/pre… If you own a legacy system nobody wants to touch, I'd like to hear what would make you trust a migration. #LegacyModernization #DigitalTransformation #TechnicalDebt #SoftwareMigration #OpenSource #EKOS

Phase 2: Day 6 🔥🦊 @ekosproject is moving beyond “knowledge for agents.” Agents can now query the knowledge, evidence, history, provenance, impact and review behind it. 🧵📎 ekos.dev/docs/

Many data professionals ask: Can AI agents access data directly from source systems instead of moving everything into a central platform? I think they can. The problem is context. Agents often lack the metadata and relationships needed to understand a system. And discovering that context on the fly can consume huge amounts of tokens. That’s why I’m building a dedicated metadata layer for AI agents — so they can understand the context first, then query source systems efficiently and economically. Data where it lives. Context where AI needs it. EKOS → alexeyban.github.io/EKOS/

Phase2 -update 4 What changed a payment’s status? Search found 202 candidate files. EKOS traced the actual path across the codebase, narrowed it to 6 relevant files, identified the authoritative field, and showed the evidence behind the answer 🧵📎👇 alexeyban.github.io/EKOS/pre…

Telegram user Tnhn asked me to test EKOS on a Postgres project, with this business problem: "When a payment fails or status changes, I can't trace where it comes from. I have to search 3 places: Postgres DB, backend code, and PDF invoices. It's hard to know which code updates payment status." What was wanted from EKOS: not just a chat answer, but a final document showing 1. Data lineage 2. Code evidence — which file/function updates payment_status 3. Links to the actual code lines / DB columns as proof I could not apply it to that project, so I took LedgerSMB — a real Perl 5 / PostgreSQL accounting ERP. I added a PostgreSQL adaptor. To get a clean result I deleted the doc/ folder and README.md, then ran EKOS on it. There is no payment_status column at all. Status lives in a workflow engine, reached through the general ledger, and exactly one function writes it. How, and the results: alexeyban.github.io/EKOS/pre…