Create an agent-owned software body from a trusted ancestor.

Genesis v0.1.1 · Enoch v0.2.0 reference body

Genesis is the OurArk creation engine. It creates a new local agent repository from an existing Genesis-compatible ancestor. By default, it creates descendants from the public our-ark/enoch body.

In practical terms, Genesis gives AI Builders a way to create, own, and evolve local agent lineages.

Genesis creates a standalone local agent repo.

That repo becomes the agent's body: its runtime, tools, memory interfaces, tests, workflows, and evolution path.

python3 -m pip install -e .

genesis create my-agent \
  --from enoch \
  --source ../enoch \
  --ref HEAD \
  --mission "Help me run my local AI-native workflow." \
  --repo ../my-agent

Then run the generated agent:

cd ../my-agent
bin/myagent

Enoch is the public reference body. Your new repository is an independently versioned descendant with fresh private state.

Most AI agents today are stateless clones: the same hidden body wrapped in different prompts, personas, and API calls.

They do not truly belong to the human who uses them.

They do not accumulate a unique life through their own code.

Genesis starts from a different belief:

AI Native is not humans using AI. AI Native is humans and AI co-evolving.

Genesis compiles a human's intent into a local agent codebase.

That codebase is the agent's body, genome, memory surface, immune system, and evolutionary history.

From there, the agent can adapt to its human, its habitat, and its work.

A Genesis-created agent is a standalone local repository with:

• its own agent identity
• its own launcher
• its own mission
• inherited code from an ancestor
• local tools and workflows
• memory interfaces
• tests and validation hooks
• an evolution path through Git

Genesis does not create a disposable prompt wrapper.

It creates the starting point of an agent lineage.

OurArk keeps source bodies and the creation engine separate:

our-ark/genesis
  public creation engine
  no bundled agent body inside
  shows how OurArk creates local agent lineages

our-ark/enoch
  public reference body
  a reference agent repo with its own body and lifecycle
  the default source for new descendants

another compatible body
  an optional public or private source
  selected explicitly with --from and --source

Genesis creates descendants from existing agents.

Enoch is a reference source, not a platform-owned runtime or a required future base. Builders can descend from another compatible public or private body by selecting it explicitly.

The goal is not one agent for humanity.

The goal is millions of evolving agents, each shaped by the judgment, values, and direction of their Builder.

This is how Builders become AI Native.

This is how co-evolution begins.

Genesis and Enoch provide a reproducible public path. Private lineages can use the same creation mechanism without publishing their source bodies, state, or history.

Credentials, memories, logs, chat identifiers, and instance state are not body content and must not appear in genesis.toml.

Requirements:

• Python 3.11, 3.12, 3.13, or 3.14
• Git

Clone the public repositories next to each other and install Genesis:

git clone https://github.com/our-ark/genesis.git
git clone https://github.com/our-ark/enoch.git
cd genesis
python3 -m pip install -e .

Inspect the exact clean source before birth:

genesis inspect-source \
  --from enoch \
  --source ../enoch \
  --ref HEAD

Then create a local descendant:

genesis create my-agent \
  --from enoch \
  --source ../enoch \
  --ref HEAD \
  --mission "Help me run my local AI-native workflow." \
  --repo ../my-agent

The generated agent is a standalone repo with its own launcher:

cd ../my-agent
bin/myagent

During development, Genesis prefers a local adjacent Enoch repo at ../enoch.

You can also point Genesis at any compatible agent repo. A remote source must be inspected first, then pinned to a full commit SHA and explicitly trusted because its inherited validation executes local code. Tags are convenient for inspection, but remote creation rejects them because tags can move:

genesis inspect-source \
  --from enoch \
  --source https://github.com/our-ark/enoch.git \
  --ref v0.2.0

genesis create my-agent \
  --from enoch \
  --mission "Help me run my local AI-native workflow." \
  --repo ../my-agent \
  --source https://github.com/our-ark/enoch.git \
  --ref c38b034ec7a80c0442734eeac1aa9e30a3e271a6 \
  --trust-source

inspect-source reports the materialized checkout, resolved commit, every tracked body file, inherited validation command, and pinned runtime dependencies. Remote checkouts are stored in the user cache directory, not inside the installed package. Set GENESIS_CACHE_DIR to choose a different writable cache location.

The source must contain exactly one tracked identity under src/. Current source bodies declare a genesis.toml body contract, and Genesis copies only the manifest's Git-tracked UTF-8 paths. A private legacy body without a manifest can still be used through the narrower convention-based compatibility path; its new descendant receives an explicit manifest at birth. Ignored or untracked artifacts such as credentials, memories, logs, instance state, and bytecode caches are never part of descent.

Before accepting birth, Genesis runs the inherited validation against a staging repository. A failed transformation, dirty validation, or failed test leaves the final target untouched. Successful birth produces an independently versioned repository and records the full parent-at-birth and descendant-birth commits in .agent/lineage.yaml.

genesis.toml declares the compatibility boundary:

schema_version = 1
package = "enoch"
body_paths = [
  ".gitignore",
  "LICENSE",
  "bin",
  "pyproject.toml",
  "src/enoch",
  "tests",
]
validation = ["-m", "unittest", "discover", "-s", "tests"]

[[runtime_dependencies]]
name = "telegram-vision"
requirement = "our-ark-telegram-vision @ git+https://github.com/our-ark/enoch.git@6d894d9beb882af7e5f57900b2323361510262de#subdirectory=libraries/telegram-vision"
import_name = "our_ark_telegram_vision"
local_source = "libraries/telegram-vision/src"
optional = true

The validation array contains arguments passed to the active Python interpreter. It is inherited and identity-transformed with the rest of the body. Manifest paths cannot include .git, .agent, or parent-relative paths.

Reusable skill implementations can live in a public ancestor repository outside body_paths and be declared with [[runtime_dependencies]]. Genesis copies the skill metadata, tests, and agent-specific adapter, but not the library source. The descendant keeps the exact dependency reference and installs it into its private runtime state when needed. VCS dependencies must use a full commit SHA; ordinary package dependencies must use an exact == version. local_source lets the owning repository validate its local library without publishing or installing it first, and must remain outside every inherited body path.

For v1, the code identity is canonicalized to one alphanumeric token so package, symbol, and environment-marker forms remain case-only transformations. For example, my-agent becomes identity Myagent, package myagent, and launcher bin/myagent; the repository path may still contain separators.

Preview permanent deletion first:

genesis recycle --repo ../my-agent --dry-run
genesis recycle --repo ../my-agent --yes

Recycle requires explicit confirmation and validates the marker, Git root, lineage metadata, and canonical identity before deleting. It never deletes a GitHub remote.

• Run the public tests: python -m unittest discover -s tests -v
• Run the Genesis × Enoch gate: python scripts/verify_enoch_descent.py --source ../enoch --ref HEAD
• Read CONTRIBUTING.md before proposing a change.
• Report vulnerabilities through the process in SECURITY.md.
• Complete the OSS release checklist before publishing a release.

This is the target architecture for Genesis-created agents.

The agent's codebase is its body.

It contains the runtime, tools, memory interfaces, communication protocols, tests, and evolution machinery.

When the agent needs to grow, it changes this body through normal software development practices:

• branches
• diffs
• tests
• reviews
• merges

The repo is where continuity lives.

The repo is where evolution becomes inspectable.

The watchdog is the life-support system.

It runs outside the agent's writable body.

It monitors the agent process, reloads it after approved upgrades, and restores the previous working state if a new body crashes.

The watchdog should be small, boring, and reliable.

The agent may call frontier cloud models for reasoning.

The cloud model is not the organism.

It is an external reasoning engine used to propose actions, plans, and mutations.

The local body remains the source of continuity, ownership, and agent identity.

To reduce hallucination risk, cloud reasoning should interact with the body through structured schemas, explicit tool calls, and local validation.

An agent cannot evolve if it destroys itself.

Every mutation should be tested before it is absorbed.

The immune system includes:

• unit tests
• integration tests
• policy checks
• budget limits
• rollback plans
• human review

Evolution is not arbitrary self-modification.

Evolution is proposed change under selection pressure.

The uniqueness of an agent should not come from a prompt alone.

It should come from:

• its inherited ancestor
• its local code history
• its tools
• its memories
• its tests
• its human's preferences
• its environment
• its approved mutations

This is the difference between a clone and a lineage.

A clone is copied.

A lineage is inherited, mutated, tested, and selected.

• Local first — the agent's body and history live on the human's machine.
• Human sovereign — the human can inspect, edit, fork, or delete the agent.
• No black-box dependency — cloud models may reason, but the local repo owns continuity.
• Evolution through Git — mutations happen through branches, diffs, tests, and review.
• Minimal core — avoid framework lock-in and unnecessary abstractions.
• Safety through structure — test, validate, budget, log, and roll back.
• Co-evolution — the human improves the agent, and the agent helps the human level up.

Genesis is the creation tool.

Enoch is the public reference body. Earlier or private Ark bodies are optional sources, not dependencies of Genesis.

Genesis creates new local descendants from an existing Genesis-style agent repo, then steps away.

The descendant becomes its own agent.

Its future belongs to its Builder.

You are not deploying a tool.

You are planting a digital seed.

Genesis gives that seed a body, a memory surface, an immune system, and a path to grow with you.

Build your agent.

Evolve yourself.

Become AI Native.

Genesis is licensed under the Apache License 2.0.