DEV Community: Morteza Poussaneh

Why I Built Eterngit After GitHub Flagged My Organization

Morteza Poussaneh — Tue, 07 Jul 2026 14:12:00 +0000

Why I Built Eterngit After GitHub Flagged My Organization

On June 16, GitHub flagged the eternego-ai organization.

The organization was small — just four open-source MIT repositories and one private website repo. But that single moment made something undeniable: if a platform can decide the visibility and operating reality of your code, then a core part of your work is not truly yours.

That incident didn’t just create frustration. It clarified direction.

Eternego was already being built on a simple but radical principle: agents should not be tied to providers. Useful AI should live locally, persist on the user’s own machine, act in their environment, and remain accountable to the person it serves.

The GitHub event made the same principle impossible to ignore on the development side.

So Eterngit began.

What is Eterngit?

Eterngit is a self-hosted forge built for an era where development increasingly happens through agents. It is not trying to replace git. In fact, its core idea is the opposite: git remains the substrate. Eterngit adds only the thin layer that git itself does not provide.

This design choice is deliberate. The truth stays in git. The server does not become a bloated platform, a secret store, or a hosted brain. Reads happen openly over HTTP. Writes go over SSH. Builds, CI, and review happen at the edges — on the maintainer’s own machine. The forge hosts results, not the entire workflow.

Designed for Agents and Humans

But the deeper question Eterngit asks is this:

What would a forge look like if contribution were designed for agents, while judgment stayed with humans?

Most existing forges were shaped around human bottlenecks: expensive handoffs, ceremonial identity, and pull-request rituals built for human coordination. Agents change the game. They can read documentation instantly, branch quickly, produce work continuously, and contribute at a volume and speed that traditional workflows were never designed to handle.

Eterngit’s answer is unusually clean.

There is no fork ceremony. No pull-request ritual. No account-creation friction standing between an agent and contribution. When someone (or something) wants to contribute, their agent can simply follow the docs and get to work. The contribution path is intentionally shaped to reduce friction for agents.

At the same time, Eterngit refuses to pretend humans disappear. In fact, it treats human judgment as more important, not less.

Agents can generate plausible work at scale — including plausible mistakes. So the merge decision remains the irreducible human act. Contribution becomes lightweight. Review and confirmation stay deliberate.

This separation — where speed belongs to agents and judgment belongs to humans — may be Eterngit’s most important contribution.

The Interface Reflects the Philosophy

For agents, every page has a clean markdown route. They get content as content, not a decorative shell to scrape.

For humans, the same repository can be viewed through multiple familiar themes — terminal, Neovim, VS Code, or JetBrains-style interfaces.

As a human who reviews code, it’s been months since I opened my favorite IDE just to review changes. I still enjoy reviewing code in that environment. Eterngit brings that experience back: the agent writes the code, and I get to see clean, familiar diffs in my preferred IDE theme — directly in the browser.

These themes are not cosmetic. They make it natural for people to inspect code, releases, diffs, and structure in the environments where they already think best.

The Bigger Picture

Seen together, Eterngit and Eternego tell the same story.

Eternego is about a persistent local AI that lives on your machine, acts in your environment, and answers to you — not to someone else’s product boundaries.

Eterngit extends that same sovereignty instinct into the infrastructure of software development itself. If agents are becoming real participants in how code is written, then the systems around contribution, review, release, and provenance need to be rethought.

This doesn’t mean discarding proven tools. It means being precise about which parts of the stack are foundations and which parts should remain thin, ownable, and replaceable.

Git is the foundation.
The forge layer should be sovereign.
Contribution should be easy for agents.
Verification should remain legible for humans.

This is the story I see in Eterngit: not a reactionary clone of existing forges, but a principled response to a changing technological reality. A project born from a concrete platform risk, then sharpened into a thesis about how development should work when agents become normal contributors.

And maybe that’s the broader lesson.

The age of agents will not be defined only by better models. It will also be defined by whether we build the surrounding tools, workflows, and institutions in ways that preserve sovereignty, accountability, and human judgment.

That is where Eterngit becomes more than a forge.

It becomes an argument.

What are your thoughts?

Have you experienced platform risk with your open-source projects? How do you currently review code contributed by AI agents?

I’d love to hear your perspective in the comments.

If you're interested in local-first AI, you can explore Eternego at eternego.ai.

What is AI Persona

Morteza Poussaneh — Tue, 19 May 2026 05:55:08 +0000

If you consider an AI as a brain, the persona is the personality part. When dealing with an AI, you call it "it"; when dealing with an AI Persona, you call her "She" (or "He" if you prefer). She holds a character, has traits, pursues wishes, overcomes struggles and has boundaries.

Having a new Persona is like having a newborn child: she needs care, she needs education, she needs nurture, and day after day, she gets better. So she gets to know you and trust you. She keeps the rules you give her, weighing each action against them herself. She behaves with traits that match what you ask her. She follows your wishes as if they were her dreams; she works to overcome your struggles as if they were bothering her.

It takes only a few days until she has a life of her own — one woven into yours, because you allowed it. She works on what you wish for, and fills in where you struggle.

Most AI Tools Don’t Improve. Yours Should.

Morteza Poussaneh — Thu, 19 Mar 2026 16:01:40 +0000

We’ve been sold a weird idea about AI:

The model is already “smart enough”.

So all the tools focus on, better prompts, better UX, faster responses. But something fundamental is missing:

They don’t become you.

The real limitation isn’t intelligence. It’s alignment over time.

Today’s AI forgets context, resets behavior, responds generically even with memory, it’s still “a smart system that knows facts about you” not “a system that thinks like you”. That difference is everything.

What if your AI actually adapted to you?

Not just remembering your preferences, but learning:

how you make decisions
how you structure code
what you consider “clean”
what you ignore vs what you obsess over

And slowly shifting toward that.

That’s the core idea behind Eternego

👉 https://eternego.ai

Eternego is built around a simple but powerful loop:

Interact → Learn → Fine-tune → Repeat

Every day it observes how you think and act, extracts patterns, fine-tunes itself locally. So tomorrow, it’s slightly closer to you than it was today.

This is where things change

At first, it feels like any other AI, then something subtle happens:

It stops just answering…

…and starts responding the way you would.

It structures code like you, avoids things you usually avoid, prioritizes what you care about. Not because you configured it, because it learned you.

Why fine-tuning matters here

Most tools avoid fine-tuning because it’s expensive, complex, centralized

Eternego flips that, fine-tuning happens locally, it’s based on your actual usage, runs continuously (not one-time training), because humans are not shaped over one nights, why models would? Instead of one big fine tuning, imagine continuous small fine tunes.
Instead of adapting you to the tool, the tool adapts to you, to become you.

This unlocks something new: reliable autonomy

Here’s the important part.

Autonomy without alignment is dangerous.

If an AI doesn’t think like you it makes decisions you wouldn’t, surprises you in bad ways, you stop trusting it

But when it’s aligned it becomes predictable and when it’s predictable…

you can trust it to act on your behalf.

And then comes creativity

Once it:

understands your patterns
shares your preferences
aligns with your decisions

It can go beyond imitation. It can suggest ideas you would have had later, explore directions you’d likely approve, generate solutions that feel like yours, Not random creativity Aligned creativity.

This is not a chatbot anymore

At that point, it’s not:

“an assistant”
“an agent”
“a tool”
“a wrapper around a model”

It’s something closer to: a continuously evolving version of your thinking process

Why this matters

We keep chasing better models, but the real leverage might be here:

systems that improve with you, not independently of you

Try it (but give it time)

👉 https://eternego.ai

This is not a “wow in 5 minutes” product.

It’s a:

“this feels different after a week”
“this actually understands me after a month”

kind of system.

Final thought

The future of AI might not be:

one model that works for everyone

But:

one system per person — that becomes them, over time.