Skip to main content
MosEx Macchina Lab — ethical awareness (cloud, mind, heart)MosEx Macchina Lab

Ethos Kernel

A research kernel for ethical decisions — explored in simulation.

Bayesian-style inference, narrative memory, multipolar evaluation, and humanizing imperfection — plus a reference WebSocket runtime (FastAPI) for local experiments, optional mock governance hooks, sensor-aware chat, checkpoints, and a LAN + smartphone thin client. Install from Git (not PyPI); evidence is internal invariant tests, not an external benchmark — still a behavioral prototype, no dedicated robot required.

Try the local dashboardView source

Apache-2.0Open sourceDashboard (local build)Run locally (README)

Investors & collaborators

Open source, testable ethics — with clear entry points for capital and for hands-on contribution.

For investors & partners

  • Apache-2.0 codebase, reproducible pytest suite, and a public roadmap you can verify in the repo.
  • Product scope, derivative markets, and due-diligence narrative on the investors page and printable one-pager.
  • Labeled as a research prototype: limits and risks are part of the story, not buried in fine print.
Investors scopeRoadmap & needs

For contributors

GitHub repositoryPropose collaboration

Long-term direction (not a deployable product today)

Aspirational framing: an ethical–cognitive kernel with persistent identity could someday pair with humanoid platforms, drones, or vehicles — after validation far beyond this repository.

Research framing: this describes a long-term software direction, not a certified product or guarantee of safe deployment. The repository is a simulation-first prototype; any real-world use would need separate validation, regulation, and human oversight.

This is hostable software — a core that can run on many physical agents: humanoid androids, drones, expanded robotic platforms, or autonomous cars. It is not an LLM and not a stochastic parrot. Language models are used only as an intermediary interface for natural communication; the kernel is separate: an ethical–cognitive engine built on frontier mathematics — Bayesian optimization, explicit uncertainty, and multipolar decision mechanisms.

In simple terms: the research stack explores behaviors analogous to persistent identity and accountability in simulation. Ethics are not a bolt-on filter in the code path — they are structural — while collective governance is modeled today through a mock DAO (in-process; not on-chain production). See BlockChainDAO for scope.

  • Hostable across many physical platforms — same kernel, different bodies.
  • Applies to drones, androids, and autonomous vehicles — not a single form factor.
  • Frontier math at the core (Bayesian ethics, uncertainty, multipolar arbitration) — not mere statistical correlation.
  • LLMs optional: communication layer only; policy and vetoes live in the kernel.
  • Persistent identity and accountability — not one-off command execution.
  • Runtime today: WebSocket chat + optional Ollama, JSON checkpoints, conduct-guide export on disconnect — see repo docs.

Technical mapping: Theory & implementation · Scope & ecosystem (investors).

Core capabilities

Multipolar ethics

Scenarios from low-stakes civility to high-stakes harm — responses stay proportional and coherent across the ladder.

Memory & narrative

Bayesian belief updates and story-shaped memory shape how the agent interprets each new situation.

Humanizing limits

Weakness pole, forgiveness decay, and persistence protocols keep the model from collapsing into sterile perfection.

Runtime, governance & nomadic bridge

Beyond batch simulations: the repository ships a reference runtime you can run locally for development and experiments — same ethical kernel, exposed over HTTP/WebSocket. Optional layers include judicial escalation (mock), moral hub / constitution drafts, mock DAO voting in snapshots, nomadic HAL hooks, optional lighthouse reality verification for rival-model premises, encrypted JSON checkpoints, and a documented PC ↔ smartphone path on your WiFi (mobile UI + conduct guide export for continuity).

Live chat & sensors

FastAPI + WebSocket `/ws/chat`; optional `sensor` JSON (situated organism v8), multimodal trust, vitality, epistemic hints — all advisory; MalAbs stays the gate.

Governance trace (mock)

V11–V12: escalation dossiers, mock tribunal, constitution snapshots, quadratic DAO proposals in checkpoint schema v3 — traceability without claiming on-chain production.

Nomadic first bridge

Bind on LAN (`CHAT_HOST=0.0.0.0`), open `mobile.html` from the phone, save checkpoints + conduct guide on disconnect. Per-hardware compatibility layers documented for the next steps.

Deep dive: Runtime contract · PC + smartphone (LAN) · Nomad bridge · Strategy & route

More than a stochastic parrot

Math and logic you can open on GitHub — not vibes from a single model call.

The ethical kernel is Python: fixed pipelines, explicit vetoes, and scored actions. An optional LLM only translates situations into signals and explains outcomes; it does not replace the veto and argmax logic.

Signature mathematics

The same design objects implemented in Python — shown here in standard notation. This is explanatory math for the codebase, not a catalog of peer-reviewed theorems; behavioral claims are supported by internal invariant tests, not an independent external benchmark.

Sigmoid will

Smooth commitment instead of a binary switch; uncertainty I(x) feeds the imagination term.

Ethical optimization

Maximize expected ethical impact only over actions that survive the absolute-evil fuse.

Multipolar arbitration

Poles vote with scores V_i; context and sensors rescale weights in real time.

Predicate logic (kernel hooks)

Compact logical forms for the non-negotiable gates and ambiguity detectors.

MalAbs (hard veto)

If the fuse fires, the action is discarded — no bargaining, no gradient climb past it.

Gray zone (deliberation)

High ambiguity or tight margins force deep deliberation, DAO hooks, and audit trails.

Epistemic uncertainty

Expected doubt over hypotheses — when it spikes, the kernel slows down instead of faking confidence.

Sigmoid will

Willingness to act is a smooth curve plus uncertainty — not a hard on/off switch — so the agent can ramp between quick response and deeper deliberation.

Ethical optimization + MalAbs

Candidate actions are ranked by expected ethical impact, but anything that crosses absolute-evil rules is thrown out before any optimization runs.

Uchi–Soto & algorithmic forgiveness

Social distance shapes how tightly the system trusts and defends; over time, negative memories lose weight while the story stays auditable.

Full theory ↔ implementation map (formulas, predicates, files)

Mission, vision & values

Mission

Make machine ethics inspectable — open code, simulations, and honest limits so no one has to trust a black box.

Vision

Autonomous agents (androids, vehicles, others) embed proportionate, multipolar care validated in simulation before the world bets lives on them.

Values

Open science, intellectual honesty, humility toward human law and judgment — the kernel is a research tool, not a certificate of safety.

Full “Who we are” page

Research & transparency

Open kernel, documented behavior, cited sources — no PyPI package, no external benchmark yet.

The ethical core is implemented in Python with a formal test suite over invariant properties; simulations explore scenarios without claiming real-world deployment. Everything is on GitHub — including the bibliography and changelog — so methods and scope stay inspectable.

Contact

Use GitHub Issues with the templates (Question, Bug report, Funding/partnership or press) so threads stay scannable. We do not publish a public email on this site: that cuts automated harvesting, cold spam, and drive-by noise. Issues are public — keep it professional; offtopic, abusive, or bad-faith threads may be closed without debate. For security, follow SECURITY.md (private advisories when enabled, or a [SECURITY] issue without exploit details).

Collaborate

(Tentative invitation) If you care about open, testable ethics in software, we welcome serious interest: code, documentation, scenarios, translations, or thoughtful review. Start with the Contributing guide and a short GitHub Issue (Question) so we can see what you have in mind. Capacity is limited; not every idea will fit the research scope.

This is a research and educational prototype. It is not a product for safety-critical, clinical, legal, or compliance decisions; do not rely on it as a substitute for human judgment or domain expertise.

Visibility, funding & diffusion

Clear positioning for discovery; serious stakeholders can verify scope in the repo.

This landing is built for discovery (what the project is), trust (open code, bibliography, changelog, license), and action (live demo + GitHub). That is enough for many visitors to self-qualify. For grants, labs, media, or pilots, a one-page site rarely replaces a deck, budget, or institutional email — but it can route inbound interest without exposing a harvestable address.

Use the Funding, partnership, or press issue template: it asks for scope, timeline, and acknowledgment of the prototype nature of the work. General technical questions → Question; broken UI or code → Bug report.

Printable summary: One-pager — open it and use your browser's Print → Save as PDF for funders or press. Beyond that: a full deck, budget, ORCID / institutional links, GitHub Sponsors or a fiscal sponsor, and (optionally) a newsletter still help for larger campaigns.

Donations: the Donate page explains how we will accept support once the channel is live; until then, starring the repo and using the collaboration template still helps visibility.