seitiate 0.1.0

Open-source Seitiate engine

Seitiate

The sovereign context engine. Open-source (AGPL-3.0). Local-first. Creator-owned.

Seitiate is the engine that builds a seity (SEE-tee) — an accumulated creative intelligence shaped by your sustained work. It connects to your data sources, accumulates context over time, governs output quality against your standards, and learns from every interaction. The result is an AI collaborator that doesn't start from zero — it continues your practice.

You own everything it produces. Your data never leaves your machine unless you send it somewhere. Your encryption keys are yours. Your seity is portable, exportable, and sovereign.

What It Does

Built to connect everywhere. The engine is designed to ingest, index, and govern creator data across many sources over time. The core standalone repo now includes the first archive-import path, and the broader connector/sink ecosystem continues to expand around it.

Accumulates context. A five-level memory hierarchy (turn → conversation → pipeline → vessel → Codex) means nothing is forgotten and everything compounds. Crystallization captures what was learned, not just what happened.

Governs quality. The Governor enforces your standards — accumulated taste, voice preferences, quality thresholds — on every output. Your Canon (what you like) plus structural checks (domain-specific failure detection) means the engine gets better at producing what you actually want.

Generates with depth. Tournaments produce multiple variants. The Society of Thought architecture debates internally before committing. Director Mode gives you editorial control over multi-pass generation. The engine doesn't guess once — it explores, then you choose.

Runs locally. Install from GitHub today (repo access required; PyPI publication is still pending), point it at Ollama or your own API keys, and you have a sovereign context engine on your machine. No cloud required for core operation. No product account required. No vendor lock-in.

Quick Start

Install status (2026-04-09): seitiate and seitiate-skills are not yet on PyPI. The only published sibling is seitiate-contracts. For now, install from a local clone of this repo. The PyPI publish workflow lives at .github/workflows/publish.yml and runs on git tag — once a v* tag is pushed, pip install seitiate will work.

Contributor install from a local clone (the only path that works today):

git clone https://github.com/gcharris/seitiate.git
cd seitiate
pip install -e ".[dev]"
pip install -e ./seitiate-skills

If you have repo access, pip install "git+https://github.com/gcharris/seitiate.git" also works against the private repo, but most users should clone first. Local talent discovery and MCP talent tools require the editable ./seitiate-skills install step above.

Then initialize and run the engine:

# Initialize a workspace
seitiate init

# Optional: initialize a named workspace instead
# seitiate init myproject && cd myproject

# Optional: import a first archive into the encrypted Codex
seitiate import google-takeout /path/to/archive.zip --tenant-id <uuid> --passphrase <passphrase>

# Configure your provider via CES_* env vars
export CES_LLM_PROVIDER=ollama

# Optional: enable Perplexity-backed cloud fallback
export CES_WEB_SEARCH_PROVIDER=perplexity
export CES_PERPLEXITY_API_KEY=your-key-here

# Start the engine
seitiate serve

The API is now running at http://127.0.0.1:8000. Connect sources, ingest content, run pipelines, and build your seity.

Architecture

Seitiate is a three-tier processing engine:

Tier 0 — Action. The orchestration kernel. Routes requests, manages pipelines, coordinates agents.

Tier 1 — Flash. Fast-path synthesis. Pluggable providers (Perplexity Sonar, local vector stores, or any synthesis engine) deliver quick answers from ingested context.

Tier 2 — Foundry. Deep-path verification. Contradiction detection, source validation, confidence scoring. What Flash proposes, Foundry verifies. Verified knowledge promotes to the Codex permanently.

The engine doesn't trust its own output by default. Every assertion can be challenged, verified, and either promoted to durable knowledge or flagged as uncertain. This is the difference between a chatbot and a context engine.

Key Concepts

Seity (SEE-tee) — Your accumulated creative intelligence. Built from your Codex (memory), Canon (taste), crystallized insights, and editorial history. Not a profile — the compounding difference between generic AI and AI that continues your practice.

Famili (fah-MEE-lee, plural: familis) — Domain-specific working entities within your seity's household. A famili for writing. A famili for code. A famili for music production. Each has specialized knowledge, voice, and constraints.

Codex — Persistent, encrypted memory. Past decisions, outputs, sources, structured knowledge, organized by trust tier. Encrypted with keys you hold.

Canon — Your accumulated taste. Quality thresholds, voice preferences, stylistic standards. The Governor checks output against your Canon before it reaches you.

Crystallization — The learning loop. After each session, the engine captures what changed — new knowledge, resolved contradictions, refined taste — and promotes it to the Codex. Your seity doesn't grow by accumulating data. It grows by learning from it.

Governor — Two-layer quality enforcement. Layer 1 (Canon governance): does this output match your standards? Layer 2 (structural checks): domain-specific failure detection, pluggable per vertical. No output ships without passing both.

Seity Bond — Cryptographically signed credential (ECDSA, JWKS, offline-verifiable) proving this seity was shaped by this human. The KYA (Know Your Agent) primitive for the agent economy.

For Hackers And Builders

Seitiate is designed as a Swiss Army Knife for hackers. Every knob is exposed, every pipeline is configurable, and the headless engine works with Claude Code, any MCP-compatible agent, or direct API calls.

The current standalone CLI surface in this repo is intentionally small:

• seitiate init initializes a local workspace
• seitiate serve runs the API
• seitiate import <adapter> ... imports one-shot archives into the encrypted Codex

Current built-in archive adapters:

• google-takeout
• twitter-archive

Near-term development is focused on the local talent and query experience, plus the package-boundary decision for future adapter expansion.

Learn More

The most useful technical entry points today are:

• docs/README.md — documentation landing page
• docs/dev-docs/README.md — curated architecture and runtime docs
• docs/ENGINEER_START_HERE.md — fast code navigation map
• CONTRIBUTING.md — development workflow and contribution rules
• DATA_HANDLING.md — local data storage and security posture
• docs/reports/seitiate-test-health-2026-03-29.md — current focused test baseline

Skill Taxonomy

Skills follow a four-tier system:

Tier	Type	Description
T1	Native	Built into the engine — Codex, Canon, Governor, Crystallization
T2	Claude Code	Skills that leverage Claude Code for execution
T3	Governed	Skills that run through the full Governor pipeline
T4	External	Community-contributed via the Bazaar marketplace

Package Boundary

The split is:

• seitiate: engine core, CLI/API surface, Codex/Canon/Governor foundations, local runtime, import boundary
• seitiate-skills: official first-party skills, connectors, sinks, and non-core add-on integrations
• seitiate-contracts: shared cross-repo schemas and contracts

Data Sovereignty

Your data is yours. Period.

• Local-first. Everything runs on your machine. No cloud dependency for core operation.
• User-held encryption. Codex, vessels, crystallization events, voice profiles, canon proposals — all encrypted with keys you hold. We can't read your data. Nobody can, unless you give them your keys.
• Portable. Export your seity, your Codex, your familis anytime. Run them in Seitiate or anywhere else.
• No monetization of creator data. Ever. The Data Sovereignty Covenant is binding. We charge rent for infrastructure, never a tax on what you create.

Project Structure

seitiate/
├── app/                   # Engine source code
│   ├── api/              # REST API (FastAPI)
│   ├── models/           # SQLAlchemy models
│   ├── services/         # Business logic
│   ├── schemas/          # Pydantic schemas
│   └── cli.py            # CLI entry point
├── tests/                # Focused standalone test suite
├── docs/                 # Reports, plans, exports, orientation
├── pyproject.toml        # Package configuration
├── CONTRIBUTING.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTORS.md
└── DATA_HANDLING.md

Related Projects

seitiate-skills — Official first-party skills, connectors, sinks, and non-core add-on integration bundle.

seitiate-contracts — Cross-repo schema contracts (on PyPI).

ClosedClaw — Infrastructure layer (identity API, managed hosting). Private repo. If you're running Seitiate locally, you don't need this.

Sakme — The paid product built on Seitiate. Marketplace, community, managed infrastructure, certification. Seitiate is fully featured without Sakme — Sakme's value is the ecosystem, not locked features.

Running Tests

# Install dev dependencies
pip install -e ".[dev]"

# Install the official add-on bundle when validating talent discovery or MCP talent tools
pip install -e ./seitiate-skills

# Run the test suite
python -m pytest tests/ -v

# Run with coverage
python -m pytest tests/ --cov=app --cov-report=term-missing

Contributing

Seitiate is AGPL-3.0 licensed. Contributions are welcome.

See CONTRIBUTING.md for contribution workflow, and the onboarding guide for standalone setup and architecture pointers.

Want to build a skill? Check the Skill Wishlist for ideas. The standalone export manifest tracks the skill-authoring docs that still need to be mirrored into this repo.

License

AGPL-3.0-or-later with the Data Sovereignty Covenant.

Software is free. Your data is yours. The ecosystem is the moat.