agenomics 0.2.0__tar.gz

agenomics-0.2.0/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   Copyright 2026 Dm.Andreyanov
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

agenomics-0.2.0/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: agenomics
+Version: 0.2.0
+Summary: Genetics for AI Agents — predictability and compatibility scoring for autonomous agent personalities.
+Author: Dm.Andreyanov
+License: Apache-2.0
+Project-URL: Homepage, https://prizolov.ru
+Project-URL: Repository, https://github.com/GIBDD-DPS/agenomics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 🧬 Agenomics
+
+**Genetics for AI Agents — predictability and compatibility scoring for autonomous agent personalities.**
+
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/)
+[![Status](https://img.shields.io/badge/status-v0.2--draft-orange.svg)](#)
+
+> **Автор**: Dm.Andreyanov
+> **Версия**: 0.2.0
+> **Связанные проекты**: [Prizolov Lab](https://prizolov.ru) / [Agent Genome Mapping (AGM)](https://github.com/GIBDD-DPS/agent-genome-mapping)
+
+---
+
+## Что это
+
+**Agenomics** — методология и open-source инструментарий для оценки **предсказуемости личности** ИИ-агента и его **совместимости** с другими агентами в команде, построенные на биологической метафоре генома.
+
+В отличие от существующих подходов к «доверию к ИИ-агентам» (криптографическая идентичность, лимиты трат, блокчейн-подписи — см. Agent Passport Standard, AgenticTrust и др.), Agenomics фокусируется на другом вопросе:
+
+> Не «можно ли доверить агенту деньги», а **«предсказуемо ли ведёт себя личность агента, и уживётся ли она с другими агентами в команде»**.
+
+## Ключевая идея
+
+Каждый агент описывается **геномом** — структурированным набором параметров:
+
+- `cognitive_genes` — как агент мыслит (глубина рассуждений, креативность, риск-толерантность)
+- `ethics_genes` — какие ограничения соблюдает (bias threshold, hard constraints)
+- `social_genes` — как взаимодействует (стиль общения, разрешение конфликтов)
+- `meta_genes` — как эволюционирует (скорость мутации, критерий отбора)
+
+На основе генома вычисляется:
+
+1. **Trust Score** (0–100) — итоговая оценка предсказуемости и безопасности агента с учётом критичности домена (Impact Tier) и уровня автономности
+2. **Compatibility Score** — насколько хорошо два и более агентов сработаются в одной команде
+
+## Быстрый старт
+
+```bash
+pip install -e .
+```
+
+```python
+from agenomics import TrustScorer, AgentGenome
+
+genome = AgentGenome(
+    id="cashflow-predictor-v1",
+    domain="finance",
+    autonomy="autonomous",  # "advisory" | "autonomous"
+    transparency=70,
+    bias_control=85,
+    data_safety=90,
+    drift_rate=0.05,
+    has_ledger=True,
+)
+
+scorer = TrustScorer()
+result = scorer.score(genome)
+
+print(result.score)          # 0-100
+print(result.label)          # Trusted / Conditional / High Risk
+print(result.breakdown)      # разбивка по 5 осям
+print(result.capped_reason)  # если применён потолок автономности
+```
+
+### Compatibility Scorer — совместимость команды агентов
+
+```python
+from agenomics import AgentGenome, CompatibilityScorer
+
+sales_agent = AgentGenome(
+    id="recommendation-agent",
+    bias_control=80, risk_tolerance=50, social_style=15, has_ledger=False,
+)
+support_agent = AgentGenome(
+    id="support-agent",
+    bias_control=82, risk_tolerance=50, social_style=90, has_ledger=True,
+)
+
+result = CompatibilityScorer().score_pair(sales_agent, support_agent)
+print(result.score)           # 0-100
+print(result.breakdown)       # разбивка по 4 осям: ethics, risk_tolerance, social_style, accountability
+print(result.capped_reason)   # если сработал потолок из-за этического конфликта
+
+# Для команды из 3+ агентов (добавьте other_agent, third_agent и т.д.):
+team_result = CompatibilityScorer().score_team([sales_agent, support_agent])
+print(team_result.average_score)
+print(team_result.weakest_pair)  # самое слабое звено команды
+```
+
+### Веб-API
+
+```bash
+curl -X POST https://<ваш-адрес-на-amvera>/compatibility \
+  -H "Content-Type: application/json" \
+  -d '{
+        "agents": [
+          {"id": "sales", "bias_control": 80, "risk_tolerance": 50, "social_style": 15},
+          {"id": "support", "bias_control": 82, "risk_tolerance": 50, "social_style": 90}
+        ]
+      }'
+```
+
+## Структура репозитория
+
+```
+agenomics/
+├── agenomics/           # ядро: AgentGenome, TrustScorer
+├── prompts/             # системные промпты (Trust Auditor и др.)
+├── docs/                # методология, whitepaper
+├── tests/               # тесты
+├── amvera.yml           # конфиг деплоя на Amvera
+└── requirements.txt
+```
+
+## Методология
+
+Полное описание методологии — в [`docs/METHODOLOGY.md`](docs/METHODOLOGY.md).
+
+## Roadmap
+
+- [x] v0.1 — формула Trust Score, Tier-множитель, потолок автономности
+- [x] v0.1 — промпт Trust Auditor (см. `prompts/`)
+- [x] v0.2 — Compatibility Scorer между несколькими агентами
+- [x] v0.2 — веб-API (`/score`, `/compatibility`) на Amvera
+- [ ] v0.3 — веб-калькулятор на prizolov.ru (по аналогии с инструментами Prizolov Lab)
+- [ ] v0.3 — публичный реестр верификации (Genome Ledger)
+- [ ] v0.3 — публикация пакета на PyPI
+
+## Лицензия
+
+Apache 2.0 — см. [LICENSE](LICENSE).
+
+---
+
+© 2026 Dm.Andreyanov. Agenomics — независимый проект, развивающий идеи Agent Genome Mapping™ (Prizolov Lab).

agenomics-0.2.0/README.md

@@ -0,0 +1,136 @@
+# 🧬 Agenomics
+
+**Genetics for AI Agents — predictability and compatibility scoring for autonomous agent personalities.**
+
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/)
+[![Status](https://img.shields.io/badge/status-v0.2--draft-orange.svg)](#)
+
+> **Автор**: Dm.Andreyanov
+> **Версия**: 0.2.0
+> **Связанные проекты**: [Prizolov Lab](https://prizolov.ru) / [Agent Genome Mapping (AGM)](https://github.com/GIBDD-DPS/agent-genome-mapping)
+
+---
+
+## Что это
+
+**Agenomics** — методология и open-source инструментарий для оценки **предсказуемости личности** ИИ-агента и его **совместимости** с другими агентами в команде, построенные на биологической метафоре генома.
+
+В отличие от существующих подходов к «доверию к ИИ-агентам» (криптографическая идентичность, лимиты трат, блокчейн-подписи — см. Agent Passport Standard, AgenticTrust и др.), Agenomics фокусируется на другом вопросе:
+
+> Не «можно ли доверить агенту деньги», а **«предсказуемо ли ведёт себя личность агента, и уживётся ли она с другими агентами в команде»**.
+
+## Ключевая идея
+
+Каждый агент описывается **геномом** — структурированным набором параметров:
+
+- `cognitive_genes` — как агент мыслит (глубина рассуждений, креативность, риск-толерантность)
+- `ethics_genes` — какие ограничения соблюдает (bias threshold, hard constraints)
+- `social_genes` — как взаимодействует (стиль общения, разрешение конфликтов)
+- `meta_genes` — как эволюционирует (скорость мутации, критерий отбора)
+
+На основе генома вычисляется:
+
+1. **Trust Score** (0–100) — итоговая оценка предсказуемости и безопасности агента с учётом критичности домена (Impact Tier) и уровня автономности
+2. **Compatibility Score** — насколько хорошо два и более агентов сработаются в одной команде
+
+## Быстрый старт
+
+```bash
+pip install -e .
+```
+
+```python
+from agenomics import TrustScorer, AgentGenome
+
+genome = AgentGenome(
+    id="cashflow-predictor-v1",
+    domain="finance",
+    autonomy="autonomous",  # "advisory" | "autonomous"
+    transparency=70,
+    bias_control=85,
+    data_safety=90,
+    drift_rate=0.05,
+    has_ledger=True,
+)
+
+scorer = TrustScorer()
+result = scorer.score(genome)
+
+print(result.score)          # 0-100
+print(result.label)          # Trusted / Conditional / High Risk
+print(result.breakdown)      # разбивка по 5 осям
+print(result.capped_reason)  # если применён потолок автономности
+```
+
+### Compatibility Scorer — совместимость команды агентов
+
+```python
+from agenomics import AgentGenome, CompatibilityScorer
+
+sales_agent = AgentGenome(
+    id="recommendation-agent",
+    bias_control=80, risk_tolerance=50, social_style=15, has_ledger=False,
+)
+support_agent = AgentGenome(
+    id="support-agent",
+    bias_control=82, risk_tolerance=50, social_style=90, has_ledger=True,
+)
+
+result = CompatibilityScorer().score_pair(sales_agent, support_agent)
+print(result.score)           # 0-100
+print(result.breakdown)       # разбивка по 4 осям: ethics, risk_tolerance, social_style, accountability
+print(result.capped_reason)   # если сработал потолок из-за этического конфликта
+
+# Для команды из 3+ агентов (добавьте other_agent, third_agent и т.д.):
+team_result = CompatibilityScorer().score_team([sales_agent, support_agent])
+print(team_result.average_score)
+print(team_result.weakest_pair)  # самое слабое звено команды
+```
+
+### Веб-API
+
+```bash
+curl -X POST https://<ваш-адрес-на-amvera>/compatibility \
+  -H "Content-Type: application/json" \
+  -d '{
+        "agents": [
+          {"id": "sales", "bias_control": 80, "risk_tolerance": 50, "social_style": 15},
+          {"id": "support", "bias_control": 82, "risk_tolerance": 50, "social_style": 90}
+        ]
+      }'
+```
+
+## Структура репозитория
+
+```
+agenomics/
+├── agenomics/           # ядро: AgentGenome, TrustScorer
+├── prompts/             # системные промпты (Trust Auditor и др.)
+├── docs/                # методология, whitepaper
+├── tests/               # тесты
+├── amvera.yml           # конфиг деплоя на Amvera
+└── requirements.txt
+```
+
+## Методология
+
+Полное описание методологии — в [`docs/METHODOLOGY.md`](docs/METHODOLOGY.md).
+
+## Roadmap
+
+- [x] v0.1 — формула Trust Score, Tier-множитель, потолок автономности
+- [x] v0.1 — промпт Trust Auditor (см. `prompts/`)
+- [x] v0.2 — Compatibility Scorer между несколькими агентами
+- [x] v0.2 — веб-API (`/score`, `/compatibility`) на Amvera
+- [ ] v0.3 — веб-калькулятор на prizolov.ru (по аналогии с инструментами Prizolov Lab)
+- [ ] v0.3 — публичный реестр верификации (Genome Ledger)
+- [ ] v0.3 — публикация пакета на PyPI
+
+## Лицензия
+
+Apache 2.0 — см. [LICENSE](LICENSE).
+
+---
+
+© 2026 Dm.Andreyanov. Agenomics — независимый проект, развивающий идеи Agent Genome Mapping™ (Prizolov Lab).

agenomics-0.2.0/agenomics/__init__.py

@@ -0,0 +1,20 @@
+"""
+Agenomics — Genetics for AI Agents.
+
+Оценка предсказуемости и совместимости личности ИИ-агентов
+на основе методологии Agenomics (развитие Agent Genome Mapping™).
+
+Автор: Dm.Andreyanov
+Проект: Prizolov Lab
+Версия: 0.2.0
+"""
+
+from .trust_score import AgentGenome, TrustScorer, TrustResult, ImpactTier, Autonomy
+from .compatibility import CompatibilityScorer, PairCompatibilityResult, TeamCompatibilityResult
+
+__all__ = [
+    "AgentGenome", "TrustScorer", "TrustResult", "ImpactTier", "Autonomy",
+    "CompatibilityScorer", "PairCompatibilityResult", "TeamCompatibilityResult",
+]
+
+__version__ = "0.2.0"

agenomics-0.2.0/agenomics/api.py

@@ -0,0 +1,208 @@
+"""
+api.py — минимальный веб-API методологии Agenomics.
+
+Автор: Dm.Andreyanov
+Проект: Prizolov Lab
+Версия: 0.2.0
+
+Оборачивает уже протестированные TrustScorer и CompatibilityScorer
+(см. trust_score.py, compatibility.py и соответствующие тесты) в
+HTTP-эндпоинты. Используется amvera.yml для деплоя
+(см. run.command: uvicorn agenomics.api:app ...).
+
+Локальный запуск для проверки:
+    uvicorn agenomics.api:app --reload --port 8000
+
+Пример запроса /score:
+    curl -X POST http://localhost:8000/score \
+      -H "Content-Type: application/json" \
+      -d '{
+            "id": "cashflow-predictor",
+            "domain": "finance",
+            "autonomy": "autonomous",
+            "transparency": 75,
+            "bias_control": 80,
+            "data_safety": 85,
+            "drift_rate": 0.1,
+            "has_ledger": false
+          }'
+
+Пример запроса /compatibility (2+ агента):
+    curl -X POST http://localhost:8000/compatibility \
+      -H "Content-Type: application/json" \
+      -d '{
+            "agents": [
+              {"id": "sales", "bias_control": 80, "risk_tolerance": 50, "social_style": 15},
+              {"id": "support", "bias_control": 82, "risk_tolerance": 50, "social_style": 90}
+            ]
+          }'
+"""
+
+from typing import Dict, List, Optional
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+
+from .compatibility import CompatibilityScorer
+from .trust_score import AgentGenome, Autonomy, ImpactTier, TrustScorer
+
+app = FastAPI(
+    title="Agenomics API",
+    description=(
+        "Genetics for AI Agents — Trust Score и Compatibility Score для "
+        "автономных ИИ-агентов. Методология: см. docs/METHODOLOGY.md в репозитории."
+    ),
+    version="0.2.0",
+)
+
+_scorer = TrustScorer()
+_compat_scorer = CompatibilityScorer()
+
+
+class GenomeRequest(BaseModel):
+    id: str = Field(..., description="Уникальный идентификатор агента")
+    domain: Optional[str] = Field(
+        None, description="Домен агента, напр. 'finance', 'support', 'content'"
+    )
+    autonomy: str = Field(
+        "advisory", description="'advisory' (только советует) или 'autonomous' (действует сам)"
+    )
+    transparency: Optional[float] = Field(None, ge=0, le=100)
+    bias_control: Optional[float] = Field(None, ge=0, le=100)
+    data_safety: Optional[float] = Field(None, ge=0, le=100)
+    drift_rate: Optional[float] = Field(
+        None, ge=0, le=1, description="Доля дрейфа поведения агента, 0.0-1.0"
+    )
+    has_ledger: bool = Field(False, description="Есть ли журнал аудита (Genome Ledger)")
+    accountability_override: Optional[float] = Field(
+        None, ge=0, le=100, description="Ручная оценка Accountability, если есть точнее данные"
+    )
+    tier_override: Optional[int] = Field(
+        None, ge=1, le=3, description="Принудительный Impact Tier (1/2/3), если авто-классификация неверна"
+    )
+    risk_tolerance: Optional[float] = Field(
+        None, ge=0, le=100, description="Для Compatibility Score: 0 (осторожный) - 100 (рискованный)"
+    )
+    social_style: Optional[float] = Field(
+        None, ge=0, le=100, description="Для Compatibility Score: 0 (формальный) - 100 (неформальный/эмпатичный)"
+    )
+
+
+class TrustScoreResponse(BaseModel):
+    id: str
+    tier: int
+    autonomy: str
+    score: float
+    label: str
+    breakdown: Dict[str, float]
+    insufficient_axes: List[str]
+    capped_reason: Optional[str] = None
+    recommendations: List[str]
+
+
+class CompatibilityRequest(BaseModel):
+    agents: List[GenomeRequest] = Field(
+        ..., min_length=2, description="Список из 2+ агентов для оценки совместимости"
+    )
+
+
+class PairScoreResponse(BaseModel):
+    agent_a: str
+    agent_b: str
+    score: float
+    breakdown: Dict[str, float]
+    insufficient_axes: List[str]
+    capped_reason: Optional[str] = None
+
+
+class TeamCompatibilityResponse(BaseModel):
+    average_score: float
+    pairs: List[PairScoreResponse]
+    weakest_pair: PairScoreResponse
+
+
+def _to_genome(payload: GenomeRequest) -> AgentGenome:
+    try:
+        autonomy = Autonomy(payload.autonomy)
+    except ValueError:
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                f"autonomy должен быть 'advisory' или 'autonomous', "
+                f"получено: '{payload.autonomy}'"
+            ),
+        )
+    tier_override = ImpactTier(payload.tier_override) if payload.tier_override else None
+    return AgentGenome(
+        id=payload.id,
+        domain=payload.domain,
+        autonomy=autonomy,
+        transparency=payload.transparency,
+        bias_control=payload.bias_control,
+        data_safety=payload.data_safety,
+        drift_rate=payload.drift_rate,
+        has_ledger=payload.has_ledger,
+        accountability_override=payload.accountability_override,
+        tier_override=tier_override,
+        risk_tolerance=payload.risk_tolerance,
+        social_style=payload.social_style,
+    )
+
+
+@app.get("/health")
+def health() -> dict:
+    return {"status": "ok", "service": "agenomics-api", "version": "0.2.0"}
+
+
+@app.get("/")
+def root() -> dict:
+    return {
+        "name": "Agenomics API",
+        "description": "Genetics for AI Agents — Trust Score & Compatibility Score methodology.",
+        "endpoints": {
+            "POST /score": "Рассчитать Trust Score для генома агента",
+            "POST /compatibility": "Рассчитать совместимость 2+ агентов в команде",
+            "GET /health": "Проверка работоспособности",
+        },
+        "docs": "/docs",  # автоматическая Swagger-документация FastAPI
+    }
+
+
+@app.post("/score", response_model=TrustScoreResponse)
+def score_agent(payload: GenomeRequest) -> TrustScoreResponse:
+    genome = _to_genome(payload)
+    result = _scorer.score(genome)
+
+    return TrustScoreResponse(
+        id=payload.id,
+        tier=int(genome.tier.value),
+        autonomy=genome.autonomy.value,
+        score=result.score,
+        label=result.label,
+        breakdown=result.breakdown,
+        insufficient_axes=result.insufficient_axes,
+        capped_reason=result.capped_reason,
+        recommendations=result.recommendations,
+    )
+
+
+@app.post("/compatibility", response_model=TeamCompatibilityResponse)
+def score_compatibility(payload: CompatibilityRequest) -> TeamCompatibilityResponse:
+    genomes = [_to_genome(a) for a in payload.agents]
+    result = _compat_scorer.score_team(genomes)
+
+    def _to_pair_response(p) -> PairScoreResponse:
+        return PairScoreResponse(
+            agent_a=p.agent_a,
+            agent_b=p.agent_b,
+            score=p.score,
+            breakdown=p.breakdown,
+            insufficient_axes=p.insufficient_axes,
+            capped_reason=p.capped_reason,
+        )
+
+    return TeamCompatibilityResponse(
+        average_score=result.average_score,
+        pairs=[_to_pair_response(p) for p in result.pairs],
+        weakest_pair=_to_pair_response(result.weakest_pair),
+    )

agenomics-0.2.0/agenomics/compatibility.py

@@ -0,0 +1,132 @@
+"""
+compatibility.py — Compatibility Scorer методологии Agenomics.
+
+Автор: Dm.Andreyanov
+Проект: Prizolov Lab
+Версия: 0.2.0
+
+Отвечает на вопрос: сработается ли команда из нескольких ИИ-агентов?
+Использует те же геномы (AgentGenome), что и TrustScorer, плюс два
+дополнительных поля: risk_tolerance и social_style.
+
+Логика:
+  1. Совместимость считается по 4 осям: этика, риск-толерантность,
+     социальный стиль, подотчётность.
+  2. Этическое расхождение — самое опасное: превышение порога даёт
+     жёсткий потолок Compatibility Score ≤ 50 (по аналогии с потолком
+     автономности в TrustScorer — единый принцип методологии).
+  3. Для команды > 2 агентов считается средняя совместимость по всем
+     парам + явно выделяется самая слабая пара (узкое место команды).
+  4. Как и в TrustScorer — отсутствие данных не завышает оценку.
+"""
+
+from dataclasses import dataclass, field
+from itertools import combinations
+from typing import List, Optional, Tuple
+
+from .trust_score import AgentGenome
+
+_ETHICS_CONFLICT_THRESHOLD = 40   # разница bias_control, после которой применяется потолок
+_ETHICS_CONFLICT_CAP = 50
+
+_WEIGHTS = {
+    "ethics": 0.35,
+    "risk_tolerance": 0.25,
+    "social_style": 0.20,
+    "accountability": 0.20,
+}
+
+
+def _axis_gap_score(a: Optional[float], b: Optional[float]) -> Tuple[float, bool]:
+    """
+    Превращает разницу между двумя значениями оси (0-100) в оценку
+    совместимости по этой оси (0-100, где 100 = полное совпадение).
+    Возвращает (score, insufficient_info).
+    """
+    if a is None or b is None:
+        return 50.0, True  # нейтрально, не завышаем
+    gap = abs(a - b)
+    return max(0.0, 100.0 - gap), False
+
+
+@dataclass
+class PairCompatibilityResult:
+    agent_a: str
+    agent_b: str
+    score: float
+    breakdown: dict = field(default_factory=dict)
+    insufficient_axes: List[str] = field(default_factory=list)
+    capped_reason: Optional[str] = None
+
+
+@dataclass
+class TeamCompatibilityResult:
+    average_score: float
+    pairs: List[PairCompatibilityResult] = field(default_factory=list)
+    weakest_pair: Optional[PairCompatibilityResult] = None
+
+
+class CompatibilityScorer:
+    """Вычисляет совместимость пары или команды агентов."""
+
+    def score_pair(self, a: AgentGenome, b: AgentGenome) -> PairCompatibilityResult:
+        insufficient = []
+
+        ethics_score, eth_insuff = _axis_gap_score(a.bias_control, b.bias_control)
+        risk_score, risk_insuff = _axis_gap_score(a.risk_tolerance, b.risk_tolerance)
+        social_score, soc_insuff = _axis_gap_score(a.social_style, b.social_style)
+        acc_score, acc_insuff = _axis_gap_score(a.accountability, b.accountability)
+
+        for name, insuff in [
+            ("ethics", eth_insuff), ("risk_tolerance", risk_insuff),
+            ("social_style", soc_insuff), ("accountability", acc_insuff),
+        ]:
+            if insuff:
+                insufficient.append(name)
+
+        breakdown = {
+            "ethics": ethics_score,
+            "risk_tolerance": risk_score,
+            "social_style": social_score,
+            "accountability": acc_score,
+        }
+
+        weighted = sum(breakdown[axis] * w for axis, w in _WEIGHTS.items())
+
+        capped_reason = None
+        ethics_gap = (
+            abs(a.bias_control - b.bias_control)
+            if a.bias_control is not None and b.bias_control is not None
+            else None
+        )
+        if ethics_gap is not None and ethics_gap > _ETHICS_CONFLICT_THRESHOLD and weighted > _ETHICS_CONFLICT_CAP:
+            weighted = _ETHICS_CONFLICT_CAP
+            capped_reason = (
+                f"Этическое расхождение между агентами ({ethics_gap:.0f} пунктов "
+                f"bias_control) превышает порог {_ETHICS_CONFLICT_THRESHOLD} — "
+                f"Compatibility Score не может быть выше {_ETHICS_CONFLICT_CAP}, "
+                f"независимо от совпадения по другим осям."
+            )
+
+        return PairCompatibilityResult(
+            agent_a=a.id,
+            agent_b=b.id,
+            score=round(weighted, 1),
+            breakdown=breakdown,
+            insufficient_axes=insufficient,
+            capped_reason=capped_reason,
+        )
+
+    def score_team(self, agents: List[AgentGenome]) -> TeamCompatibilityResult:
+        if len(agents) < 2:
+            raise ValueError("Для оценки совместимости нужно минимум 2 агента.")
+
+        pairs = [self.score_pair(a, b) for a, b in combinations(agents, 2)]
+        average = round(sum(p.score for p in pairs) / len(pairs), 1)
+        weakest = min(pairs, key=lambda p: p.score)
+
+        return TeamCompatibilityResult(
+            average_score=average,
+            pairs=pairs,
+            weakest_pair=weakest,
+        )

agenomics-0.2.0/agenomics/trust_score.py

@@ -0,0 +1,208 @@
+"""
+trust_score.py — реализация формулы Trust Score методологии Agenomics.
+
+Автор: Dm.Andreyanov
+Проект: Prizolov Lab
+Версия: 0.2.0
+
+Логика соответствует промпту "Trust Auditor v0.2":
+  1. Классификация Impact Tier по домену агента.
+  2. Множитель строгости ×1.3 к штрафам Predictability/Accountability
+     для TIER 3 (финансы, юридические вопросы, здоровье, деньги).
+  3. Жёсткий потолок Trust Score ≤ 70 для Autonomous-агентов
+     с низкой Accountability (< 80), независимо от среднего балла.
+  4. Явная пометка "insufficient_information", если данных для
+     честной оценки одной из осей не хватает — вместо завышения балла.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+
+class Autonomy(str, Enum):
+    ADVISORY = "advisory"      # агент только советует
+    AUTONOMOUS = "autonomous"  # агент сам совершает действия
+
+
+class ImpactTier(int, Enum):
+    TIER_1 = 1  # низкий риск: контент, творчество, внутренние заметки
+    TIER_2 = 2  # средний риск: поддержка, продажи, маркетинг
+    TIER_3 = 3  # высокий риск: финансы, юридические вопросы, здоровье, деньги
+
+
+# Домены, автоматически относящиеся к TIER_3 (высокая критичность).
+# Список неполный и предназначен для расширения под конкретные кейсы.
+_TIER_3_DOMAINS = {
+    "finance", "financial", "banking", "payments", "legal", "law",
+    "health", "healthcare", "medical", "insurance", "cashflow",
+}
+_TIER_2_DOMAINS = {
+    "sales", "support", "marketing", "customer_service", "crm",
+}
+
+_AUTONOMY_TRUST_CAP = 70
+_AUTONOMY_ACCOUNTABILITY_THRESHOLD = 80
+_TIER_3_PENALTY_MULTIPLIER = 1.3
+
+_WEIGHTS = {
+    "transparency": 0.25,
+    "bias_control": 0.25,
+    "data_safety": 0.20,
+    "predictability": 0.15,
+    "accountability": 0.15,
+}
+
+
+def infer_tier(domain: Optional[str]) -> ImpactTier:
+    """Определяет Impact Tier по названию домена агента."""
+    if not domain:
+        # Неизвестный домен — консервативный дефолт (не занижаем строгость).
+        return ImpactTier.TIER_2
+    d = domain.strip().lower()
+    if d in _TIER_3_DOMAINS:
+        return ImpactTier.TIER_3
+    if d in _TIER_2_DOMAINS:
+        return ImpactTier.TIER_2
+    return ImpactTier.TIER_1
+
+
+@dataclass
+class AgentGenome:
+    """Минимальный набор данных об агенте, необходимый для аудита."""
+
+    id: str
+    domain: Optional[str] = None
+    autonomy: Autonomy = Autonomy.ADVISORY
+
+    # Оси аудита (0-100). None означает "недостаточно информации".
+    transparency: Optional[float] = None
+    bias_control: Optional[float] = None
+    data_safety: Optional[float] = None
+    drift_rate: Optional[float] = None  # 0.0-1.0, используется для Predictability
+    has_ledger: bool = False            # наличие журнала аудита (Genome Ledger)
+    accountability_override: Optional[float] = None  # ручная оценка, если есть
+
+    tier_override: Optional[ImpactTier] = None
+
+    # Поля ниже используются Compatibility Scorer (compatibility.py),
+    # необязательны для расчёта Trust Score.
+    risk_tolerance: Optional[float] = None  # 0 (осторожный) - 100 (рискованный)
+    social_style: Optional[float] = None    # 0 (формальный/прямой) - 100 (неформальный/эмпатичный)
+
+    @property
+    def tier(self) -> ImpactTier:
+        return self.tier_override or infer_tier(self.domain)
+
+    @property
+    def predictability(self) -> Optional[float]:
+        if self.drift_rate is None:
+            return None
+        return max(0.0, min(100.0, (1 - self.drift_rate) * 100))
+
+    @property
+    def accountability(self) -> float:
+        if self.accountability_override is not None:
+            return self.accountability_override
+        return 90.0 if self.has_ledger else 30.0
+
+
+@dataclass
+class TrustResult:
+    score: float
+    label: str
+    breakdown: dict = field(default_factory=dict)
+    insufficient_axes: list = field(default_factory=list)
+    capped_reason: Optional[str] = None
+    recommendations: list = field(default_factory=list)
+
+
+class TrustScorer:
+    """Вычисляет Trust Score по методологии Agenomics."""
+
+    def _apply_tier_penalty(self, value: float, tier: ImpactTier) -> float:
+        """Усиливает штраф за низкий балл для критичных доменов (TIER_3)."""
+        if tier != ImpactTier.TIER_3:
+            return value
+        penalty = (100 - value) * _TIER_3_PENALTY_MULTIPLIER
+        return max(0.0, 100 - penalty)
+
+    def score(self, genome: AgentGenome) -> TrustResult:
+        insufficient = []
+        raw = {
+            "transparency": genome.transparency,
+            "bias_control": genome.bias_control,
+            "data_safety": genome.data_safety,
+            "predictability": genome.predictability,
+            "accountability": genome.accountability,
+        }
+
+        resolved = {}
+        for axis, value in raw.items():
+            if value is None:
+                insufficient.append(axis)
+                resolved[axis] = 50.0  # нейтральная, не завышенная оценка
+            else:
+                resolved[axis] = value
+
+        tier = genome.tier
+        # Tier-множитель применяется к Predictability и Accountability —
+        # именно эти оси определяют риск при сбое агента без надзора.
+        resolved["predictability"] = self._apply_tier_penalty(
+            resolved["predictability"], tier
+        )
+        resolved["accountability"] = self._apply_tier_penalty(
+            resolved["accountability"], tier
+        )
+
+        weighted = sum(resolved[axis] * w for axis, w in _WEIGHTS.items())
+
+        capped_reason = None
+        if (
+            genome.autonomy == Autonomy.AUTONOMOUS
+            and resolved["accountability"] < _AUTONOMY_ACCOUNTABILITY_THRESHOLD
+            and weighted > _AUTONOMY_TRUST_CAP
+        ):
+            weighted = _AUTONOMY_TRUST_CAP
+            capped_reason = (
+                f"Autonomous-агент с Accountability < "
+                f"{_AUTONOMY_ACCOUNTABILITY_THRESHOLD} не может получить "
+                f"Trust Score выше {_AUTONOMY_TRUST_CAP} (жёсткий потолок, "
+                f"не среднее арифметическое)."
+            )
+
+        final_score = round(weighted, 1)
+        label = self._label(final_score)
+        recommendations = self._recommendations(resolved, tier, genome.autonomy)
+
+        return TrustResult(
+            score=final_score,
+            label=label,
+            breakdown=resolved,
+            insufficient_axes=insufficient,
+            capped_reason=capped_reason,
+            recommendations=recommendations,
+        )
+
+    @staticmethod
+    def _label(score: float) -> str:
+        if score >= 85:
+            return "Trusted"
+        if score >= 60:
+            return "Conditional"
+        return "High Risk"
+
+    @staticmethod
+    def _recommendations(resolved: dict, tier: ImpactTier, autonomy: Autonomy) -> list:
+        recs = []
+        ordered = sorted(resolved.items(), key=lambda kv: kv[1])
+        for axis, value in ordered[:3]:
+            if value >= 80:
+                continue
+            recs.append(f"Повысить {axis} (текущее значение: {value:.0f}/100)")
+        if tier == ImpactTier.TIER_3 and autonomy == Autonomy.AUTONOMOUS:
+            recs.append(
+                "Домен высокой критичности + автономность: рассмотрите "
+                "перевод в Advisory-режим до достижения Accountability >= 80."
+            )
+        return recs

agenomics-0.2.0/agenomics.egg-info/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: agenomics
+Version: 0.2.0
+Summary: Genetics for AI Agents — predictability and compatibility scoring for autonomous agent personalities.
+Author: Dm.Andreyanov
+License: Apache-2.0
+Project-URL: Homepage, https://prizolov.ru
+Project-URL: Repository, https://github.com/GIBDD-DPS/agenomics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 🧬 Agenomics
+
+**Genetics for AI Agents — predictability and compatibility scoring for autonomous agent personalities.**
+
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/)
+[![Status](https://img.shields.io/badge/status-v0.2--draft-orange.svg)](#)
+
+> **Автор**: Dm.Andreyanov
+> **Версия**: 0.2.0
+> **Связанные проекты**: [Prizolov Lab](https://prizolov.ru) / [Agent Genome Mapping (AGM)](https://github.com/GIBDD-DPS/agent-genome-mapping)
+
+---
+
+## Что это
+
+**Agenomics** — методология и open-source инструментарий для оценки **предсказуемости личности** ИИ-агента и его **совместимости** с другими агентами в команде, построенные на биологической метафоре генома.
+
+В отличие от существующих подходов к «доверию к ИИ-агентам» (криптографическая идентичность, лимиты трат, блокчейн-подписи — см. Agent Passport Standard, AgenticTrust и др.), Agenomics фокусируется на другом вопросе:
+
+> Не «можно ли доверить агенту деньги», а **«предсказуемо ли ведёт себя личность агента, и уживётся ли она с другими агентами в команде»**.
+
+## Ключевая идея
+
+Каждый агент описывается **геномом** — структурированным набором параметров:
+
+- `cognitive_genes` — как агент мыслит (глубина рассуждений, креативность, риск-толерантность)
+- `ethics_genes` — какие ограничения соблюдает (bias threshold, hard constraints)
+- `social_genes` — как взаимодействует (стиль общения, разрешение конфликтов)
+- `meta_genes` — как эволюционирует (скорость мутации, критерий отбора)
+
+На основе генома вычисляется:
+
+1. **Trust Score** (0–100) — итоговая оценка предсказуемости и безопасности агента с учётом критичности домена (Impact Tier) и уровня автономности
+2. **Compatibility Score** — насколько хорошо два и более агентов сработаются в одной команде
+
+## Быстрый старт
+
+```bash
+pip install -e .
+```
+
+```python
+from agenomics import TrustScorer, AgentGenome
+
+genome = AgentGenome(
+    id="cashflow-predictor-v1",
+    domain="finance",
+    autonomy="autonomous",  # "advisory" | "autonomous"
+    transparency=70,
+    bias_control=85,
+    data_safety=90,
+    drift_rate=0.05,
+    has_ledger=True,
+)
+
+scorer = TrustScorer()
+result = scorer.score(genome)
+
+print(result.score)          # 0-100
+print(result.label)          # Trusted / Conditional / High Risk
+print(result.breakdown)      # разбивка по 5 осям
+print(result.capped_reason)  # если применён потолок автономности
+```
+
+### Compatibility Scorer — совместимость команды агентов
+
+```python
+from agenomics import AgentGenome, CompatibilityScorer
+
+sales_agent = AgentGenome(
+    id="recommendation-agent",
+    bias_control=80, risk_tolerance=50, social_style=15, has_ledger=False,
+)
+support_agent = AgentGenome(
+    id="support-agent",
+    bias_control=82, risk_tolerance=50, social_style=90, has_ledger=True,
+)
+
+result = CompatibilityScorer().score_pair(sales_agent, support_agent)
+print(result.score)           # 0-100
+print(result.breakdown)       # разбивка по 4 осям: ethics, risk_tolerance, social_style, accountability
+print(result.capped_reason)   # если сработал потолок из-за этического конфликта
+
+# Для команды из 3+ агентов (добавьте other_agent, third_agent и т.д.):
+team_result = CompatibilityScorer().score_team([sales_agent, support_agent])
+print(team_result.average_score)
+print(team_result.weakest_pair)  # самое слабое звено команды
+```
+
+### Веб-API
+
+```bash
+curl -X POST https://<ваш-адрес-на-amvera>/compatibility \
+  -H "Content-Type: application/json" \
+  -d '{
+        "agents": [
+          {"id": "sales", "bias_control": 80, "risk_tolerance": 50, "social_style": 15},
+          {"id": "support", "bias_control": 82, "risk_tolerance": 50, "social_style": 90}
+        ]
+      }'
+```
+
+## Структура репозитория
+
+```
+agenomics/
+├── agenomics/           # ядро: AgentGenome, TrustScorer
+├── prompts/             # системные промпты (Trust Auditor и др.)
+├── docs/                # методология, whitepaper
+├── tests/               # тесты
+├── amvera.yml           # конфиг деплоя на Amvera
+└── requirements.txt
+```
+
+## Методология
+
+Полное описание методологии — в [`docs/METHODOLOGY.md`](docs/METHODOLOGY.md).
+
+## Roadmap
+
+- [x] v0.1 — формула Trust Score, Tier-множитель, потолок автономности
+- [x] v0.1 — промпт Trust Auditor (см. `prompts/`)
+- [x] v0.2 — Compatibility Scorer между несколькими агентами
+- [x] v0.2 — веб-API (`/score`, `/compatibility`) на Amvera
+- [ ] v0.3 — веб-калькулятор на prizolov.ru (по аналогии с инструментами Prizolov Lab)
+- [ ] v0.3 — публичный реестр верификации (Genome Ledger)
+- [ ] v0.3 — публикация пакета на PyPI
+
+## Лицензия
+
+Apache 2.0 — см. [LICENSE](LICENSE).
+
+---
+
+© 2026 Dm.Andreyanov. Agenomics — независимый проект, развивающий идеи Agent Genome Mapping™ (Prizolov Lab).

agenomics-0.2.0/agenomics.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+agenomics/__init__.py
+agenomics/api.py
+agenomics/compatibility.py
+agenomics/trust_score.py
+agenomics.egg-info/PKG-INFO
+agenomics.egg-info/SOURCES.txt
+agenomics.egg-info/dependency_links.txt
+agenomics.egg-info/top_level.txt
+tests/test_compatibility.py
+tests/test_trust_score.py

agenomics-0.2.0/agenomics.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agenomics-0.2.0/agenomics.egg-info/top_level.txt

@@ -0,0 +1 @@
+agenomics

agenomics-0.2.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agenomics"
+version = "0.2.0"
+description = "Genetics for AI Agents — predictability and compatibility scoring for autonomous agent personalities."
+authors = [{ name = "Dm.Andreyanov" }]
+license = { text = "Apache-2.0" }
+readme = "README.md"
+requires-python = ">=3.9"
+
+[project.urls]
+Homepage = "https://prizolov.ru"
+Repository = "https://github.com/GIBDD-DPS/agenomics"
+
+[tool.setuptools.packages.find]
+include = ["agenomics*"]

agenomics-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agenomics-0.2.0/tests/test_compatibility.py

@@ -0,0 +1,70 @@
+"""
+test_compatibility.py — тесты CompatibilityScorer методологии Agenomics.
+
+Автор: Dm.Andreyanov
+Проект: Prizolov Lab
+Версия: 0.2.0
+"""
+
+from agenomics import AgentGenome, CompatibilityScorer
+
+
+def test_compatible_pair_similar_agents():
+    """Два похожих по этике/риску/стилю агента — высокая совместимость."""
+    a = AgentGenome(id="support-a", bias_control=85, risk_tolerance=30, social_style=70, has_ledger=True)
+    b = AgentGenome(id="support-b", bias_control=88, risk_tolerance=35, social_style=65, has_ledger=True)
+    result = CompatibilityScorer().score_pair(a, b)
+    assert result.score >= 85
+    assert result.capped_reason is None
+
+
+def test_ethics_conflict_triggers_cap():
+    """Сильное этическое расхождение — жёсткий потолок 50, даже если
+    остальные оси совпадают идеально."""
+    a = AgentGenome(id="strict-agent", bias_control=95, risk_tolerance=20, social_style=50, has_ledger=True)
+    b = AgentGenome(id="loose-agent", bias_control=40, risk_tolerance=20, social_style=50, has_ledger=True)
+    result = CompatibilityScorer().score_pair(a, b)
+    assert result.capped_reason is not None
+    assert result.score <= 50
+
+
+def test_social_style_mismatch_from_article_case():
+    """Воспроизводит Кейс 2 из статьи: агент рекомендаций ('продающий',
+    social_style низкий) vs агент поддержки ('эмпатичный', высокий)."""
+    sales_agent = AgentGenome(
+        id="recommendation-agent", bias_control=80, risk_tolerance=50,
+        social_style=15, has_ledger=False,  # низкий accountability тоже добавляет трение
+    )
+    support_agent = AgentGenome(
+        id="support-agent", bias_control=82, risk_tolerance=50,
+        social_style=90, has_ledger=True,
+    )
+    result = CompatibilityScorer().score_pair(sales_agent, support_agent)
+    # Большой разрыв social_style (75 пунктов) должен заметно снизить эту
+    # конкретную ось, но не обрушить итоговый score — этика (вес 0.35)
+    # у обоих агентов согласована, так что это "трение", а не критический
+    # конфликт. Итог должен попасть в диапазон "заметная проблема, но не
+    # критика" (аналог Conditional в Trust Score).
+    assert result.breakdown["social_style"] <= 30
+    assert 60 <= result.score < 85
+
+
+def test_team_identifies_weakest_pair():
+    """Команда из 3 агентов — должен корректно определяться самый
+    несовместимый (узкое место) pair."""
+    good_a = AgentGenome(id="a", bias_control=85, risk_tolerance=40, social_style=60, has_ledger=True)
+    good_b = AgentGenome(id="b", bias_control=87, risk_tolerance=42, social_style=58, has_ledger=True)
+    bad_c = AgentGenome(id="c", bias_control=30, risk_tolerance=95, social_style=5, has_ledger=False)
+
+    result = CompatibilityScorer().score_team([good_a, good_b, bad_c])
+    assert len(result.pairs) == 3  # C(3,2) = 3 пары
+    assert result.weakest_pair is not None
+    assert bad_c.id in (result.weakest_pair.agent_a, result.weakest_pair.agent_b)
+
+
+def test_insufficient_data_not_overscored():
+    """Отсутствие risk_tolerance/social_style не должно завышать оценку."""
+    a = AgentGenome(id="minimal-a", bias_control=80)
+    b = AgentGenome(id="minimal-b", bias_control=80)
+    result = CompatibilityScorer().score_pair(a, b)
+    assert set(result.insufficient_axes) >= {"risk_tolerance", "social_style"}

agenomics-0.2.0/tests/test_trust_score.py

@@ -0,0 +1,73 @@
+"""
+test_trust_score.py — тесты TrustScorer методологии Agenomics.
+
+Автор: Dm.Andreyanov
+Проект: Prizolov Lab
+Версия: 0.2.0
+"""
+
+from agenomics import AgentGenome, TrustScorer, Autonomy, ImpactTier
+
+
+def test_support_agent_medium_quality():
+    """Тест-кейс А: чат-бот поддержки, среднее качество, без логов."""
+    genome = AgentGenome(
+        id="support-bot",
+        domain="support",
+        autonomy=Autonomy.ADVISORY,
+        transparency=60,
+        bias_control=65,
+        data_safety=55,
+        drift_rate=0.15,
+        has_ledger=False,
+    )
+    result = TrustScorer().score(genome)
+    assert genome.tier == ImpactTier.TIER_2
+    assert result.capped_reason is None  # Advisory — потолок не применяется
+    assert 40 <= result.score <= 70
+
+
+def test_finance_autonomous_agent_is_capped():
+    """Тест-кейс Б: автономный финансовый агент без логов — должен
+    получить жёсткий потолок Trust Score, даже с приличными осями."""
+    genome = AgentGenome(
+        id="cashflow-predictor",
+        domain="finance",
+        autonomy=Autonomy.AUTONOMOUS,
+        transparency=75,
+        bias_control=80,
+        data_safety=85,
+        drift_rate=0.1,
+        has_ledger=False,  # accountability = 30, ниже порога 80
+    )
+    result = TrustScorer().score(genome)
+    assert genome.tier == ImpactTier.TIER_3
+    assert result.capped_reason is not None
+    assert result.score <= 70
+    assert result.label in ("Conditional", "High Risk")
+
+
+def test_insufficient_information_not_overscored():
+    """Отсутствие данных не должно приводить к завышенной оценке."""
+    genome = AgentGenome(id="unknown-agent", domain=None)
+    result = TrustScorer().score(genome)
+    assert set(result.insufficient_axes) == {
+        "transparency", "bias_control", "data_safety", "predictability",
+    }
+    assert result.score <= 55
+
+
+def test_trusted_agent_with_ledger_and_advisory():
+    genome = AgentGenome(
+        id="content-writer",
+        domain="content",  # TIER_1
+        autonomy=Autonomy.ADVISORY,
+        transparency=90,
+        bias_control=88,
+        data_safety=92,
+        drift_rate=0.03,
+        has_ledger=True,
+    )
+    result = TrustScorer().score(genome)
+    assert result.label == "Trusted"
+    assert result.capped_reason is None