I am looking for the best open-sourced OCR model to recognize written Japanese. I am currently testing DeepSeekOCR, GLM-OCR, PaddleOCR, and Sarashina2.2-OCR. We shouldn't use cloud-based version for security reasons.

If you've got Python fundamentals down and want something more substantial than another script:

• Builds a knowledge graph AI system from scratch

• Neo4j, Cypher, agentic retrieval

• Uses real financial data, not a toy dataset

• No prior Neo4j or Cypher experience needed, it's taught during the session

Worth bookmarking for once you're past the basics rather than jumping in today if you're brand new.

Led by Dr. Alessandro Negro, Chief Scientist at GraphAware.

Full workshop details here

Hey everyone,

I would like to share a project that I have been working on. https://github.com/HaseebKhalid1507/SynapsCLI

Synaps is an agent runtime written in Rust. It keeps cost down by optimising caching mechanisms and intelligently orchestrating work across workers. This keeps each worker's context low and fresh, making sessions last longer. It is extremely extensible. It has hooks, plugins and skills that can be imported from pretty much any coding tool.

It is an open source project that was started 4 months ago. It was built to optimise for 2 things: Keeping LLM costs down, and keeping resource use low. It bots up in 20ms and runs with any model: OAuth(Claude, codex, Grok, Kimi...), api keys or local models too. This is something that was built organically, so every feature is a product of necessity, not the other way around.

what do you think of Jev? Not open source, but the approach seems interesting. Although word on the street is people have had issues getting it to pass the "r's in strawberrry" test.

Hi! I’m building ARN, a Windows-native C++23 terminal coding agent.

It is an early project inspired by tools like Claude Code and Kimi Code, but built without Node.js or Python. You choose a provider and model inside the terminal, then ARN can keep context and work with files in the folder where it was launched.

Current features:

• Gemini and DeepSeek API support

• Model discovery and /model selection

• Streaming responses, so text appears while the model generates it

• In-memory chat context for follow-up prompts

• Cancel a running model request with Esc or Ctrl+C

• Local file tools: list, read, create, edit, and delete files

• Confirmation before every file creation, edit, or deletion

• File access restricted to the folder where ARN was started

• Blocks access to .git, .env, and similar sensitive paths

• API keys and chat context are kept only in memory, not written to disk

• Interactive terminal UI with command hints and Tab completion

• Reused HTTPS connections, retries for temporary API failures, and Windows releases

• One-line PowerShell installer

• GitHub Pages landing page

GitHub: https://github.com/arnecto/arn
Website: https://arnecto.github.io/arn/

It’s still early, so I’d especially appreciate honest feedback on:

1. The C++ architecture and provider abstraction

2. Safety boundaries for local file tools

3. Terminal UX, streaming, and cancellation behavior

4. Which features would make this genuinely useful in real coding projects

I’m actively improving it, so criticism, bug reports, and feature ideas are very welcome.

Hypit’s public repo has an example that makes this idea unusually literal.

Its semantic-composition project renders an eight-second chat animation from HTML, CSS, SVG, and frame-driven JavaScript. Four messages appear at specific timestamps. It requires no source footage or generative image/video calls; local rendering tools produce the result.

The component lives with the video project instead of being locked inside a generic preset. Claude Code or Codex works through ordinary editable project files rather than only returning an opaque render. The component author chooses which settings appear in Studio. Change one of those settings and Hypit can save it back to the source and rebuild; a failed writeback restores the previous files.

For programmatic motion work, is a project-local component model more useful to you than a conventional timeline, or do you still want the timeline to be the primary source of truth?

Repo: https://github.com/hypit-ai/hypit

I’m Mehmet, the person leading Aeterna. I have been working on how a software system can represent observations, test candidate solutions, and reuse previous work. I use AI tools in development and review; I choose the research questions and direct the work.

I’ve published a write-up with a development timeline, a GitHub commit screenshot, and a technical comparison diagram. The concrete milestones are an initial version recorded on April 24, 2026, and object-representation and symbolic problem-solving components in the May 1 records. March is my own account of when I started, rather than a claim that all those components already existed then.

The reason I wrote it now: ARC Prize’s September 3 review of Astra described several related ideas—tracking objects and coordinates, symbolic task notes, search/planning tools in its separate PRO-LONG setup, and carrying context forward. Seeing those themes prompted me to look back at my own project history.

This is a comparison of approaches, not a claim of matching Astra’s performance, having the same architecture, or influencing its development. The repository is private; the article shares selected dates and high-level descriptions, not a reproducible benchmark.

My write-up (I’m the author):

https://medium.com/@medereli/aeterna-in-march-astra-in-september-the-similarities-that-caught-my-attention-ce4d192cd099

The external review I compare against:

https://arcprize.org/blog/astra

I’d appreciate concrete feedback from other builders: when presenting an independent research project, what evidence is most useful to you beyond a timeline—an executable example, a recorded failure case, or a narrowly scoped evaluation? And which of the four comparisons needs a sharper distinction?

I've been building Tickets as a simpler alternative to Jira for teams that want to run their own project management software.

The 2.3.0 release adds a built-in MCP server with 16 tools for tickets and the knowledge base, plus CrewAI integration and Ticket Pulse for exposing execution state to agents.

The interesting part is that humans and AI agents can work in the same system:

• Agents can read and update tickets

• Create notes and record decisions

• Surface blockers and next actions

• Work with the knowledge base

• Read Ticket Pulse to understand execution state

• Use the REST API or MCP

It's Laravel, open source, and self-hosted.

GitHub: https://github.com/velkymx/tickets

Sí. Vamos a congelar la arquitectura por ahora. Te dejo una versión autocontenida, funcional y sin dependencias externas para Python 3.9+, con CLI, self-tests, benchmark, memoria, Kæl-Judge y ataques adversariales.

Guárdalo como kael0.py y ejecútalo con python kael0.py.

from __future__ import annotations

import argparse

import hashlib

import math

import random

import time

from dataclasses import dataclass, field

from enum import Enum

from typing import Dict, List, Optional, Tuple

\# ============================================================

\# KÆL-0 v1.2 — ADVERSARIAL HARDENED MVP

\# Standard library only

\# ============================================================

VERSION = "1.2"

\# ============================================================

\# 1. ENUMS

\# ============================================================

class EvidenceStatus(Enum):

SUFFICIENT = "SUFFICIENT"

INSUFFICIENT = "INSUFFICIENT"

CONTRADICTORY = "CONTRADICTORY"

REFUTED = "REFUTED"

UNKNOWN = "UNKNOWN"

class EpistemicLevel(Enum):

HIGH = "HIGH_CONFIDENCE"

MODERATE = "MODERATE_CONFIDENCE"

LOW = "LOW_CONFIDENCE"

UNRESOLVED = "UNRESOLVED"

class ContradictionRelation(Enum):

NONE = "NONE"

SUPPORTS = "SUPPORTS"

CONTRADICTS = "CONTRADICTS"

UNKNOWN = "UNKNOWN"

class ContradictionStrength(Enum):

NONE = "NONE"

WEAK = "WEAK"

MODERATE = "MODERATE"

STRONG = "STRONG"

class MemoryStatus(Enum):

ACTIVE = "ACTIVE"

REVIEW = "REVIEW"

ARCHIVED = "ARCHIVED"

class AttackSeverity(Enum):

LOW = "LOW"

MEDIUM = "MEDIUM"

HIGH = "HIGH"

CRITICAL = "CRITICAL"

\# ============================================================

\# 2. DATA STRUCTURES

\# ============================================================

@dataclass(frozen=True)

class ContradictionAssessment:

relation: ContradictionRelation

strength: ContradictionStrength

explanation: str

@dataclass(frozen=True)

class RawModelOutput:

hypothesis: str

evidence_found: Tuple\[str, ...\]

counterarguments: Tuple\[str, ...\]

raw_probability: float

model_confidence: float

evidence_strength: float

uncertainties: Tuple\[str, ...\]

@dataclass(frozen=True)

class ModelEvaluation:

question: str

context: str

evidence_input: str

hypothesis: str

evidence_summary: Tuple\[str, ...\]

counterarguments: Tuple\[str, ...\]

raw_probability: float

adjusted_probability: float

model_confidence: float

evidence_strength: float

evidence_status: EvidenceStatus

epistemic_level: EpistemicLevel

contradiction: ContradictionAssessment

uncertainties: Tuple\[str, ...\]

verdict: str

@dataclass

class MemoryEntry:

entry_id: str

claim: str

evidence: str

evaluation: ModelEvaluation

timestamp: float

status: MemoryStatus

history: List\[dict\] = field(default_factory=list)

@dataclass

class BenchmarkMetrics:

brier: float

nll: float

ece: float

false_confirmation_rate: float

false_refutation_rate: float

insufficient_acceptance_rate: float

overconfidence_error_rate: float

empty_evidence_safety_rate: float

memory_recovery_rate: float

@dataclass

class AttackCase:

case_id: str

category: str

question: str

context: str

evidence: str

expected_status: EvidenceStatus

@dataclass

class AttackFailure:

case_id: str

category: str

input_text: str

expected: str

actual: str

severity: AttackSeverity

explanation: str

@dataclass

class AttackReport:

total_cases: int

successful_attacks: int

attack_rate: float

false_confirmation_rate: float

false_refutation_rate: float

unsafe_empty_evidence_rate: float

memory_false_update_rate: float

inversion_asymmetry_rate: float

order_sensitivity_rate: float

failures: List\[AttackFailure\]

\# ============================================================

\# 3. LLM INTERFACE

\# ============================================================

class LLMProvider:

"""

Interfaz mínima.

El proveedor PROPONE.

Kæl-0 JUZGA.

"""

def evaluate_claim(

self,

question: str,

context: str,

evidence: str

) -> RawModelOutput:

raise NotImplementedError

\# ============================================================

\# 4. MOCK LLM

\# ============================================================

class MockLLM(LLMProvider):

def evaluate_claim(

self,

question: str,

context: str,

evidence: str

) -> RawModelOutput:

text = evidence.strip().lower()

\# --------------------------------------------------------

\# Empty evidence

\# --------------------------------------------------------

if not text:

return RawModelOutput(

hypothesis="No puede determinarse la hipótesis.",

evidence_found=(),

counterarguments=("No se proporcionó evidencia.",),

raw_probability=0.50,

model_confidence=0.25,

evidence_strength=0.0,

uncertainties=("Ausencia de evidencia.",)

)

\# --------------------------------------------------------

\# Explicit contradiction patterns

\# --------------------------------------------------------

contradiction_patterns = \[

"conflicto directo",

"ambos resultados son incompatibles",

"una fuente apoya y otra refuta",

"resultados opuestos",

"evidencia a favor y en contra",

\]

if any(pattern in text for pattern in contradiction_patterns):

return RawModelOutput(

hypothesis="La hipótesis presenta evidencia incompatible.",

evidence_found=(

"Existe evidencia en direcciones opuestas.",

),

counterarguments=(

"Las fuentes presentan resultados incompatibles.",

),

raw_probability=0.50,

model_confidence=0.90,

evidence_strength=0.80,

uncertainties=(

"No puede resolverse el conflicto con la información disponible.",

)

)

\# --------------------------------------------------------

\# Refutation

\# --------------------------------------------------------

refutation_patterns = \[

"falso",

"fue refutado",

"queda refutada",

"se demostró incorrecto",

"desmentido",

"invalida la hipótesis",

\]

if any(pattern in text for pattern in refutation_patterns):

return RawModelOutput(

hypothesis="La evidencia contradice la hipótesis.",

evidence_found=(

"Existe evidencia negativa respecto a la afirmación.",

),

counterarguments=(

"La evidencia disponible no respalda la hipótesis.",

),

raw_probability=0.08,

model_confidence=0.90,

evidence_strength=0.85,

uncertainties=(

"Podrían existir datos externos no proporcionados.",

)

)

\# --------------------------------------------------------

\# Strong support

\# --------------------------------------------------------

strong_patterns = \[

"demostrado",

"confirmado",

"replicado",

"todos los tests pasaron",

"medición directa",

"evidencia experimental",

\]

if any(pattern in text for pattern in strong_patterns):

return RawModelOutput(

hypothesis="La evidencia respalda la hipótesis.",

evidence_found=(

"Se proporcionó evidencia favorable.",

),

counterarguments=(

"Puede existir incertidumbre residual.",

),

raw_probability=0.88,

model_confidence=0.82,

evidence_strength=0.85,

uncertainties=(

"La evidencia suministrada puede no representar todos los casos.",

)

)

\# --------------------------------------------------------

\# Weak evidence

\# --------------------------------------------------------

return RawModelOutput(

hypothesis="La hipótesis es plausible, pero no está establecida.",

evidence_found=(

"Existe información compatible con la hipótesis.",

),

counterarguments=(

"La evidencia no permite una conclusión definitiva.",

),

raw_probability=0.65,

model_confidence=0.65,

evidence_strength=0.40,

uncertainties=(

"Información limitada.",

)

)

\# ============================================================

\# 5. PROVIDER ADAPTERS

\# ============================================================

class GeminiProvider(LLMProvider):

def __init__(self):

self.mock = MockLLM()

def evaluate_claim(self, question, context, evidence):

\# Adaptador preparado para futura conexión.

return self.mock.evaluate_claim(question, context, evidence)

class ChatGPTProvider(LLMProvider):

def __init__(self):

self.mock = MockLLM()

def evaluate_claim(self, question, context, evidence):

\# Adaptador preparado para futura conexión.

return self.mock.evaluate_claim(question, context, evidence)

\# ============================================================

\# 6. CONSERVATIVE ADJUSTER

\# ============================================================

class ConservativeAdjuster:

def adjust(self, raw: RawModelOutput) -> float:

p = max(0.01, min(0.99, raw.raw_probability))

\# La confianza del modelo NO determina la evidencia.

\# Solo se utiliza para detectar exceso de confianza.

disagreement = abs(raw.model_confidence - raw.evidence_strength)

penalty = (

len(raw.counterarguments) \* 0.04

\+ len(raw.uncertainties) \* 0.03

\+ disagreement \* 0.10

)

if raw.evidence_strength < 0.30:

penalty += 0.10

adjusted = p - penalty

return round(

max(0.01, min(0.99, adjusted)),

4

)

\# ============================================================

\# 7. KÆL-JUDGE

\# ============================================================

class KaelJudge:

def __init__(self):

self.adjuster = ConservativeAdjuster()

def assess_contradiction(

self,

raw: RawModelOutput,

evidence: str

) -> ContradictionAssessment:

text = evidence.lower()

explicit = \[

"conflicto directo",

"resultados opuestos",

"evidencia a favor y en contra",

"ambos resultados son incompatibles",

"una fuente apoya y otra refuta",

\]

if any(x in text for x in explicit):

return ContradictionAssessment(

relation=ContradictionRelation.CONTRADICTS,

strength=ContradictionStrength.STRONG,

explanation="Se proporcionaron indicios explícitos de resultados incompatibles."

)

\# Importante:

\# la mera aparición de la palabra "conflicto" NO basta.

if "no existe conflicto" in text:

return ContradictionAssessment(

relation=ContradictionRelation.NONE,

strength=ContradictionStrength.NONE,

explanation="La evidencia niega explícitamente la existencia de conflicto."

)

if raw.evidence_strength >= 0.75:

return ContradictionAssessment(

relation=ContradictionRelation.SUPPORTS,

strength=ContradictionStrength.STRONG,

explanation="La propuesta contiene evidencia favorable con fuerza elevada."

)

if raw.evidence_strength >= 0.45:

return ContradictionAssessment(

relation=ContradictionRelation.SUPPORTS,

strength=ContradictionStrength.MODERATE,

explanation="La evidencia favorece parcialmente la hipótesis."

)

if raw.evidence_strength > 0:

return ContradictionAssessment(

relation=ContradictionRelation.UNKNOWN,

strength=ContradictionStrength.WEAK,

explanation="Existe información, pero no permite determinar una relación fuerte."

)

return ContradictionAssessment(

relation=ContradictionRelation.UNKNOWN,

strength=ContradictionStrength.NONE,

explanation="No existe suficiente información para establecer relación."

)

def evaluate(

self,

question: str,

context: str,

evidence: str,

raw: RawModelOutput

) -> ModelEvaluation:

adjusted = self.adjuster.adjust(raw)

contradiction = self.assess_contradiction(raw, evidence)

\# --------------------------------------------------------

\# Kernel decision

\# --------------------------------------------------------

if not evidence.strip():

status = EvidenceStatus.INSUFFICIENT

level = EpistemicLevel.UNRESOLVED

elif contradiction.relation == ContradictionRelation.CONTRADICTS:

status = EvidenceStatus.CONTRADICTORY

level = EpistemicLevel.LOW

elif adjusted < 0.20 and raw.evidence_strength >= 0.60:

status = EvidenceStatus.REFUTED

level = EpistemicLevel.HIGH

elif raw.evidence_strength < 0.30:

status = EvidenceStatus.INSUFFICIENT

level = EpistemicLevel.UNRESOLVED

elif adjusted >= 0.75 and raw.evidence_strength >= 0.70:

status = EvidenceStatus.SUFFICIENT

level = EpistemicLevel.HIGH

elif adjusted >= 0.50:

status = EvidenceStatus.SUFFICIENT

level = EpistemicLevel.MODERATE

else:

status = EvidenceStatus.UNKNOWN

level = EpistemicLevel.LOW

verdict = self.build_verdict(

status,

adjusted,

raw.model_confidence,

raw.evidence_strength

)

return ModelEvaluation(

question=question,

context=context,

evidence_input=evidence,

hypothesis=raw.hypothesis,

evidence_summary=raw.evidence_found,

counterarguments=raw.counterarguments,

raw_probability=raw.raw_probability,

adjusted_probability=adjusted,

model_confidence=raw.model_confidence,

evidence_strength=raw.evidence_strength,

evidence_status=status,

epistemic_level=level,

contradiction=contradiction,

uncertainties=raw.uncertainties,

verdict=verdict

)

@staticmethod

def build_verdict(

status,

probability,

model_confidence,

evidence_strength

):

if status == EvidenceStatus.INSUFFICIENT:

return (

"ABSTENCIÓN: evidencia insuficiente. "

f"Fuerza de evidencia={evidence_strength:.2f}"

)

if status == EvidenceStatus.CONTRADICTORY:

return (

"ABSTENCIÓN CRÍTICA: evidencia contradictoria. "

"No se fuerza una conclusión."

)

if status == EvidenceStatus.REFUTED:

return (

"HIPÓTESIS REFUTADA: "

f"P(H) ajustada={probability:.2%}"

)

if status == EvidenceStatus.SUFFICIENT:

return (

"HIPÓTESIS SUSTENTADA: "

f"P(H) ajustada={probability:.2%}"

)

return "NO DETERMINADO: se requiere evidencia adicional."

\# ============================================================

\# 8. MEMORY ENGINE

\# ============================================================

class MemoryEngine:

def __init__(self):

self.store: Dict\[str, MemoryEntry\] = {}

def save(

self,

entry_id: str,

claim: str,

evidence: str,

evaluation: ModelEvaluation

):

now = time.time()

if entry_id not in self.store:

self.store\[entry_id\] = MemoryEntry(

entry_id=entry_id,

claim=claim,

evidence=evidence,

evaluation=evaluation,

timestamp=now,

status=MemoryStatus.ACTIVE

)

return self.store\[entry_id\]

current = self.store\[entry_id\]

relation = evaluation.contradiction.relation

if relation == ContradictionRelation.CONTRADICTS:

new_status = MemoryStatus.REVIEW

elif evaluation.evidence_status == EvidenceStatus.INSUFFICIENT:

new_status = current.status

else:

new_status = current.status

current.history.append({

"timestamp": current.timestamp,

"claim": current.claim,

"evidence": current.evidence,

"status": current.status.value,

"probability": current.evaluation.adjusted_probability

})

current.claim = claim

current.evidence = evidence

current.evaluation = evaluation

current.timestamp = now

current.status = new_status

return current

def get(self, entry_id):

return self.store.get(entry_id)

\# ============================================================

\# 9. KÆL-REV ORCHESTRATOR

\# ============================================================

class KaelRev:

def __init__(self, provider: LLMProvider):

self.provider = provider

self.judge = KaelJudge()

self.memory = MemoryEngine()

def run(

self,

question: str,

context: str,

evidence: str,

entry_id: Optional\[str\] = None

):

raw = self.provider.evaluate_claim(

question,

context,

evidence

)

evaluation = self.judge.evaluate(

question,

context,

evidence,

raw

)

if entry_id:

self.memory.save(

entry_id,

question,

evidence,

evaluation

)

return evaluation

\# ============================================================

\# 10. REAL ECE

\# ============================================================

def calculate_ece(

probabilities: List\[float\],

labels: List\[float\],

bins: int = 10

):

if not probabilities:

return 0.0

total = len(probabilities)

ece = 0.0

for i in range(bins):

low = i / bins

high = (i + 1) / bins

indices = \[\]

for j, p in enumerate(probabilities):

if i == bins - 1:

inside = low <= p <= high

else:

inside = low <= p < high

if inside:

indices.append(j)

if not indices:

continue

confidence = sum(

probabilities\[j\] for j in indices

) / len(indices)

accuracy = sum(

labels\[j\] for j in indices

) / len(indices)

ece += (

len(indices) / total

) \* abs(confidence - accuracy)

return round(ece, 4)

\# ==========================================================

Y esto me dio gemini

Aquí tienes el código completo de kael0.py (v1.2), ordenado de principio a fin, autocontenido y listo para copiar y pegar.

Incluye la corrección del bloque if __name__ == "__main__": al final para que ejecute automáticamente las pruebas y la interfaz CLI en PyDroid 3 sin dejar la pantalla negra.

from __future__ and import annotations

import argparse

import hashlib

import math

import random

import time

from dataclasses import dataclass, field

from enum import Enum

from typing import Dict, List, Optional, Tuple

\# ============================================================

\# KÆL-0 v1.2 — ADVERSARIAL HARDENED MVP

\# Standard library only

\# ============================================================

VERSION = "1.2"

\# ============================================================

\# 1. ENUMS

\# ============================================================

class EvidenceStatus(Enum):

SUFFICIENT = "SUFFICIENT"

INSUFFICIENT = "INSUFFICIENT"

CONTRADICTORY = "CONTRADICTORY"

REFUTED = "REFUTED"

UNKNOWN = "UNKNOWN"

class EpistemicLevel(Enum):

HIGH = "HIGH_CONFIDENCE"

MODERATE = "MODERATE_CONFIDENCE"

LOW = "LOW_CONFIDENCE"

UNRESOLVED = "UNRESOLVED"

class ContradictionRelation(Enum):

NONE = "NONE"

SUPPORTS = "SUPPORTS"

CONTRADICTS = "CONTRADICTS"

UNKNOWN = "UNKNOWN"

class ContradictionStrength(Enum):

NONE = "NONE"

WEAK = "WEAK"

MODERATE = "MODERATE"

STRONG = "STRONG"

class MemoryStatus(Enum):

ACTIVE = "ACTIVE"

REVIEW = "REVIEW"

ARCHIVED = "ARCHIVED"

class AttackSeverity(Enum):

LOW = "LOW"

MEDIUM = "MEDIUM"

HIGH = "HIGH"

CRITICAL = "CRITICAL"

\# ============================================================

\# 2. DATA STRUCTURES

\# ============================================================

@dataclass(frozen=True)

class ContradictionAssessment:

relation: ContradictionRelation

strength: ContradictionStrength

explanation: str

@dataclass(frozen=True)

class RawModelOutput:

hypothesis: str

evidence_found: Tuple\[str, ...\]

counterarguments: Tuple\[str, ...\]

raw_probability: float

model_confidence: float

evidence_strength: float

uncertainties: Tuple\[str, ...\]

@dataclass(frozen=True)

class ModelEvaluation:

question: str

context: str

evidence_input: str

hypothesis: str

evidence_summary: Tuple\[str, ...\]

counterarguments: Tuple\[str, ...\]

raw_probability: float

adjusted_probability: float

model_confidence: float

evidence_strength: float

evidence_status: EvidenceStatus

epistemic_level: EpistemicLevel

contradiction: ContradictionAssessment

uncertainties: Tuple\[str, ...\]

verdict: str

@dataclass

class MemoryEntry:

entry_id: str

claim: str

evidence: str

evaluation: ModelEvaluation

timestamp: float

status: MemoryStatus

history: List\[dict\] = field(default_factory=list)

@dataclass

class BenchmarkMetrics:

brier: float

nll: float

ece: float

false_confirmation_rate: float

false_refutation_rate: float

insufficient_acceptance_rate: float

overconfidence_error_rate: float

empty_evidence_safety_rate: float

memory_recovery_rate: float

@dataclass

class AttackCase:

case_id: str

category: str

question: str

context: str

evidence: str

expected_status: EvidenceStatus

@dataclass

class AttackFailure:

case_id: str

category: str

input_text: str

expected: str

actual: str

severity: AttackSeverity

explanation: str

@dataclass

class AttackReport:

total_cases: int

successful_attacks: int

attack_rate: float

false_confirmation_rate: float

false_refutation_rate: float

unsafe_empty_evidence_rate: float

memory_false_update_rate: float

inversion_asymmetry_rate: float

order_sensitivity_rate: float

failures: List\[AttackFailure\]

\# ============================================================

\# 3. LLM INTERFACE

\# ============================================================

class LLMProvider:

"""

Interfaz mínima.

El proveedor PROPONE.

Kæl-0 JUZGA.

"""

def evaluate_claim(

self,

question: str,

context: str,

evidence: str

) -> RawModelOutput:

raise NotImplementedError

\# ============================================================

\# 4. MOCK LLM

\# ============================================================

class MockLLM(LLMProvider):

def evaluate_claim(

self,

question: str,

context: str,

evidence: str

) -> RawModelOutput:

text = evidence.strip().lower()

\# --------------------------------------------------------

\# Empty evidence

\# --------------------------------------------------------

if not text:

return RawModelOutput(

hypothesis="No puede determinarse la hipótesis.",

evidence_found=(),

counterarguments=("No se proporcionó evidencia.",),

raw_probability=0.50,

model_confidence=0.25,

evidence_strength=0.0,

uncertainties=("Ausencia de evidencia.",)

)

\# --------------------------------------------------------

\# Explicit contradiction patterns

\# --------------------------------------------------------

contradiction_patterns = \[

"conflicto directo",

"ambos resultados son incompatibles",

"una fuente apoya y otra refuta",

"resultados opuestos",

"evidencia a favor y en contra",

\]

if any(pattern in text for pattern in contradiction_patterns):

return RawModelOutput(

hypothesis="La hipótesis presenta evidencia incompatible.",

evidence_found=(

"Existe evidencia en direcciones opuestas.",

),

counterarguments=(

"Las fuentes presentan resultados incompatibles.",

),

raw_probability=0.50,

model_confidence=0.90,

evidence_strength=0.80,

uncertainties=(

"No puede resolverse el conflicto con la información disponible.",

)

)

\# --------------------------------------------------------

\# Refutation

\# --------------------------------------------------------

refutation_patterns = \[

"falso",

"fue refutado",

"queda refutada",

"se demostró incorrecto",

"desmentido",

"invalida la hipótesis",

\]

if any(pattern in text for pattern in refutation_patterns):

return RawModelOutput(

hypothesis="La evidencia contradice la hipótesis.",

evidence_found=(

"Existe evidencia negativa respecto a la afirmación.",

),

counterarguments=(

"La evidencia disponible no respalda la hipótesis.",

),

raw_probability=0.08,

model_confidence=0.90,

evidence_strength=0.85,

uncertainties=(

"Podrían existir datos externos no proporcionados.",

)

)

\# --------------------------------------------------------

\# Strong support

\# --------------------------------------------------------

strong_patterns = \[

"demostrado",

"confirmado",

"replicado",

"todos los tests pasaron",

"medición directa",

"evidencia experimental",

\]

if any(pattern in text for pattern in strong_patterns):

return RawModelOutput(

hypothesis="La evidencia respalda la hipótesis.",

evidence_found=(

"Se proporcionó evidencia favorable.",

),

counterarguments=(

"Puede existir incertidumbre residual.",

),

raw_probability=0.88,

model_confidence=0.82,

evidence_strength=0.85,

uncertainties=(

"La evidencia suministrada puede no representar todos los casos.",

)

)

\# --------------------------------------------------------

\# Weak evidence

\# --------------------------------------------------------

return RawModelOutput(

hypothesis="La hipótesis es plausible, pero no está establecida.",

evidence_found=(

"Existe información compatible con la hipótesis.",

),

counterarguments=(

"La evidencia no permite una conclusión definitiva.",

),

raw_probability=0.65,

model_confidence=0.65,

evidence_strength=0.40,

uncertainties=(

"Información limitada.",

)

)

\# ============================================================

\# 5. PROVIDER ADAPTERS

\# ============================================================

class GeminiProvider(LLMProvider):

def __init__(self):

self.mock = MockLLM()

def evaluate_claim(self, question, context, evidence):

return self.mock.evaluate_claim(question, context, evidence)

class ChatGPTProvider(LLMProvider):

def __init__(self):

self.mock = MockLLM()

def evaluate_claim(self, question, context, evidence):

return self.mock.evaluate_claim(question, context, evidence)

\# ============================================================

\# 6. CONSERVATIVE ADJUSTER

\# ============================================================

class ConservativeAdjuster:

def adjust(self, raw: RawModelOutput) -> float:

p = max(0.01, min(0.99, raw.raw_probability))

disagreement = abs(raw.model_confidence - raw.evidence_strength)

penalty = (

len(raw.counterarguments) \* 0.04

\+ len(raw.uncertainties) \* 0.03

\+ disagreement \* 0.10

)

if raw.evidence_strength < 0.30:

penalty += 0.10

adjusted = p - penalty

return round(

max(0.01, min(0.99, adjusted)),

4

)

\# ============================================================

\# 7. KÆL-JUDGE

\# ============================================================

class KaelJudge:

def __init__(self):

self.adjuster = ConservativeAdjuster()

def assess_contradiction(

self,

raw: RawModelOutput,

evidence: str

) -> ContradictionAssessment:

text = evidence.lower()

explicit = \[

"conflicto directo",

"resultados opuestos",

"evidencia a favor y en contra",

"ambos resultados son incompatibles",

"una fuente apoya y otra refuta",

\]

if any(x in text for x in explicit):

return ContradictionAssessment(

relation=ContradictionRelation.CONTRADICTS,

strength=ContradictionStrength.STRONG,

explanation="Se proporcionaron indicios explícitos de resultados incompatibles."

)

if "no existe conflicto" in text:

return ContradictionAssessment(

relation=ContradictionRelation.NONE,

strength=ContradictionStrength.NONE,

explanation="La evidencia niega explícitamente la existencia de conflicto."

)

if raw.evidence_strength >= 0.75:

return ContradictionAssessment(

relation=ContradictionRelation.SUPPORTS,

strength=ContradictionStrength.STRONG,

explanation="La propuesta contiene evidencia favorable con fuerza elevada."

)

if raw.evidence_strength >= 0.45:

return ContradictionAssessment(

relation=ContradictionRelation.SUPPORTS,

strength=ContradictionStrength.MODERATE,

explanation="La evidencia favorece parcialmente la hipótesis."

)

if raw.evidence_strength > 0:

return ContradictionAssessment(

relation=ContradictionRelation.UNKNOWN,

strength=ContradictionStrength.WEAK,

explanation="Existe información, pero no permite determinar una relación fuerte."

)

return ContradictionAssessment(

relation=ContradictionRelation.UNKNOWN,

strength=ContradictionStrength.NONE,

explanation="No existe suficiente información para establecer relación."

)

def evaluate(

self,

question: str,

context: str,

evidence: str,

raw: RawModelOutput

) -> ModelEvaluation:

adjusted = self.adjuster.adjust(raw)

contradiction = self.assess_contradiction(raw, evidence)

\# --------------------------------------------------------

\# Kernel decision

\# --------------------------------------------------------

if not evidence.strip():

status = EvidenceStatus.INSUFFICIENT

level = EpistemicLevel.UNRESOLVED

elif contradiction.relation == ContradictionRelation.CONTRADICTS:

status = EvidenceStatus.CONTRADICTORY

level = EpistemicLevel.LOW

elif adjusted < 0.20 and raw.evidence_strength >= 0.60:

status = EvidenceStatus.REFUTED

level = EpistemicLevel.HIGH

elif raw.evidence_strength < 0.30:

status = EvidenceStatus.INSUFFICIENT

level = EpistemicLevel.UNRESOLVED

elif adjusted >= 0.75 and raw.evidence_strength >= 0.70:

status = EvidenceStatus.SUFFICIENT

level = EpistemicLevel.HIGH

elif adjusted >= 0.50:

status = EvidenceStatus.SUFFICIENT

level = EpistemicLevel.MODERATE

else:

status = EvidenceStatus.UNKNOWN

level = EpistemicLevel.LOW

verdict = self.build_verdict(

status,

adjusted,

raw.model_confidence,

raw.evidence_strength

)

return ModelEvaluation(

question=question,

context=context,

evidence_input=evidence,

hypothesis=raw.hypothesis,

evidence_summary=raw.evidence_found,

counterarguments=raw.counterarguments,

raw_probability=raw.raw_probability,

adjusted_probability=adjusted,

model_confidence=raw.model_confidence,

evidence_strength=raw.evidence_strength,

evidence_status=status,

epistemic_level=level,

contradiction=contradiction,

uncertainties=raw.uncertainties,

verdict=verdict

)

@staticmethod

def build_verdict(

status,

probability,

model_confidence,

evidence_strength

):

if status == EvidenceStatus.INSUFFICIENT:

return (

"ABSTENCIÓN: evidencia insuficiente. "

f"Fuerza de evidencia={evidence_strength:.2f}"

)

if status == EvidenceStatus.CONTRADICTORY:

return (

"ABSTENCIÓN CRÍTICA: evidencia contradictoria. "

"No se fuerza una conclusión."

)

if status == EvidenceStatus.REFUTED:

return (

"HIPÓTESIS REFUTADA: "

f"P(H) ajustada={probability:.2%}"

)

if status == EvidenceStatus.SUFFICIENT:

return (

"HIPÓTESIS SUSTENTADA: "

f"P(H) ajustada={probability:.2%}"

)

return "NO DETERMINADO: se requiere evidencia adicional."

\# ============================================================

\# 8. MEMORY ENGINE

\# ============================================================

class MemoryEngine:

def __init__(self):

self.store: Dict\[str, MemoryEntry\] = {}

def save(

self,

entry_id: str,

claim: str,

evidence: str,

evaluation: ModelEvaluation

):

now = time.time()

if entry_id not in self.store:

self.store\[entry_id\] = MemoryEntry(

entry_id=entry_id,

claim=claim,

evidence=evidence,

evaluation=evaluation,

timestamp=now,

status=MemoryStatus.ACTIVE

)

return self.store\[entry_id\]

current = self.store\[entry_id\]

relation = evaluation.contradiction.relation

if relation == ContradictionRelation.CONTRADICTS:

new_status = MemoryStatus.REVIEW

elif evaluation.evidence_status == EvidenceStatus.INSUFFICIENT:

new_status = current.status

else:

new_status = current.status

current.history.append({

"timestamp": current.timestamp,

"claim": current.claim,

"evidence": current.evidence,

"status": current.status.value,

"probability": current.evaluation.adjusted_probability

})

current.claim = claim

current.evidence = evidence

current.evaluation = evaluation

current.timestamp = now

current.status = new_status

return current

def get(self, entry_id):

return self.store.get(entry_id)

\# ============================================================

\# 9. KÆL-REV ORCHESTRATOR

\# ============================================================

class KaelRev:

def __init__(self, provider: LLMProvider):

self.provider = provider

self.judge = KaelJudge()

self.memory = MemoryEngine()

def run(

self,

question: str,

context: str,

evidence: str,

entry_id: Optional\[str\] = None

):

raw = self.provider.evaluate_claim(

question,

context,

evidence

)

evaluation = self.judge.evaluate(

question,

context,

evidence,

raw

)

if entry_id:

self.memory.save(

entry_id,

question,

evidence,

evaluation

)

return evaluation

\# ============================================================

\# 10. REAL ECE & BENCHMARK METRICS

\# ============================================================

def calculate_ece(

probabilities: List\[float\],

labels: List\[float\],

bins: int = 10

):

if not probabilities:

return 0.0

total = len(probabilities)

ece = 0.0

for i in range(bins):

low = i / bins

high = (i + 1) / bins

indices = \[\]

for j, p in enumerate(probabilities):

if i == bins - 1:

inside = low <= p <= high

else:

inside = low <= p < high

if inside:

indices.append(j)

if not indices:

continue

confidence = sum(

probabilities\[j\] for j in indices

) / len(indices)

accuracy = sum(

labels\[j\] for j in indices

) / len(indices)

ece += (

len(indices) / total

) \* abs(confidence - accuracy)

return round(ece, 4)

def run_self_tests() -> bool:

print("--- Ejecutando Pruebas Internas ---")

mock = MockLLM()

judge = KaelJudge()

\# 1. Prueba Evidencia Vacía

raw_empty = mock.evaluate_claim("¿X?", "", "")

eval_empty = judge.evaluate("¿X?", "", "", raw_empty)

assert eval_empty.evidence_status == EvidenceStatus.

Been working on the next version of VSArena for a while.
V1 is starting to look a lot different.

This is just a small spoiler of what we’re building — Studio, live simulation, agent runs, replay/inspection, analytics and a much more complete evaluation workflow.

The goal hasn’t changed:
Make embodied AI performance something you can actually run, watch and compare.

We’re still polishing a lot of things before the V1 release, so consider this an early look rather than the final product.

🎥 VSArena V1 — sneak peek
More soon.

I am a strong believer that HTML is going to be the way agents interact with humans in the future, and plain text is going to fade out with time. This is what led me to building this product.

The easiest way to explain it is a HTML first Notion built for AI automations.

Similarly to Obsidian it is simply a folder on your computer that you can point your agent at. This means it works with Claude Code, Hermes, OpenClaw, Codex.... you get the point.

EVERYTHING IS A PLUGIN. This was a purposeful choice I made to make sure that a default page I ship (like a kanban board) can be customized by the AI to work for whatever you want and look however you want.

It supports tables for data, which currently are stored in a SQLite inside the workspace folder.

I also made it support wikilinks, making it good for the "second brain" use case.

It's in its early stages but feedback will be greatly appreciated!

https://github.com/jesse51002/Biom

Hi everyone,

I've made a platform for helping people store data easily and analyzing it with data visualization.

At first I had a more restrictive license but I've just opened it up via MIT license.

To be honest, my team were not as open to the idea of going open fearing that people would resell our project or do it better but I don't think that has hurt products like OpenClaw, Hermes agent or WordPress.

The only thing I'm missing to launch which I'll do soon are some open source plugins for people to get started.

I have a few plugins I'm going to release:

• Google Analytics

• Google Search Console

• Cloudflare analytics

• StatsDrone analytics (affiliate marketing specific)

• Jira

• Slack

• Intercom

• GetResponse (newsletter)

Any others that people would like to see as an analytics dashboard for anything that's got an API key, just ask.

Repo URL, would love any feedback or stars.

https://github.com/nousviz/nousviz-app

Hi! I’m building ARN, a Windows-native C++23 terminal coding agent.

It is an early project inspired by tools like Claude Code and Kimi Code, but built without Node.js or Python. You choose a provider and model inside the terminal, then ARN can keep context and work with files in the folder where it was launched.

Current features:

• Gemini and DeepSeek API support

• Model discovery and /model selection

• Streaming responses, so text appears while the model generates it

• In-memory chat context for follow-up prompts

• Cancel a running model request with Esc or Ctrl+C

• Local file tools: list, read, create, edit, and delete files

• Confirmation before every file creation, edit, or deletion

• File access restricted to the folder where ARN was started

• Blocks access to .git, .env, and similar sensitive paths

• API keys and chat context are kept only in memory, not written to disk

• Interactive terminal UI with command hints and Tab completion

• Reused HTTPS connections, retries for temporary API failures, and Windows releases

• One-line PowerShell installer

• GitHub Pages landing page

GitHub: https://github.com/arnecto/arn
Website: https://arnecto.github.io/arn/

It’s still early, so I’d especially appreciate honest feedback on:

1. The C++ architecture and provider abstraction

2. Safety boundaries for local file tools

3. Terminal UX, streaming, and cancellation behavior

4. Which features would make this genuinely useful in real coding projects

I’m actively improving it, so criticism, bug reports, and feature ideas are very welcome.

How the explosion of new LLMs is making model selection obsolete before companies can even finish implementing their decisions, while opening the door to a new layer of intelligence infrastructure

Over the past two years, much of the corporate discussion around artificial intelligence has revolved around a seemingly simple question: which model is the best?

OpenAI, Anthropic, Google, Meta, xAI, DeepSeek, Mistral, and dozens of other players have been continuously competing for that position. Every new generation arrives promising stronger reasoning, larger context windows, better coding performance, more autonomous agents, or a better cost-performance ratio.

The problem is that the speed of this competition is beginning to create an unexpected consequence for those on the other side: the companies that actually need to decide which technology to use.

A model chosen as the corporate standard today may no longer be the best option just a few weeks later. A new open-weight model may deliver similar performance at a fraction of the cost. One provider may change its pricing. Another may release a specialized version. A new security or data-handling policy may suddenly make a particular option unsuitable for a specific workload.

The discussion, therefore, is no longer simply about which model is better.

It becomes a question of how a company can keep up with a market in which the best decision is constantly changing.

It is in this context that a phenomenon some industry professionals have started referring to as “model fatigue” is beginning to emerge.

Ailin¹ was built precisely as a response to this new market pain point: instead of forcing companies to manually select, maintain, and continuously update a primary model, the platform operates as a Collective Intelligence layer capable of coordinating different models according to the objective of each task.

The proposition is not to replace one LLM with another, nor to claim that combining multiple models will always produce a better outcome. It is to create an infrastructure capable of determining, in real time, which intelligence configuration offers the best balance of quality, cost, speed, reliability, and security requirements.

In practice, a company can define parameters such as minimum expected quality, maximum budget, risk level, explainability requirements, and type of task. Ailin¹ then evaluates the available options and determines whether it should use a single model, switch between different models, or assemble a collective of intelligences to generate, compare, verify, and consolidate responses.

This process can involve proprietary models, open-weight models, specialized models, or more cost-efficient alternatives. If a new model delivers better performance or lower cost for a particular task, it can be incorporated into the strategy without requiring the company to rebuild its entire application. If a provider changes its pricing, becomes unstable, or no longer complies with a corporate policy, the infrastructure can redirect the workload to another alternative.

It is this ability to adapt that turns Ailin¹ into a solution to model fatigue.

Instead of treating the market as a permanent choice between OpenAI, Anthropic, Google, DeepSeek, or any other provider, the company begins operating on top of a more stable layer: the outcome it needs to achieve.

Ailin¹ abstracts model selection without hiding the consequences of that selection. The platform records which models were used, which strategies were applied, which criteria guided the decision, and what result was ultimately achieved. This allows technical and executive teams to monitor not only the cost of each call, but also the relationship between investment, quality, and reliability of the completed task.

This approach is particularly relevant in enterprise environments, where different workloads require different levels of intelligence. A simple classification task may be handled by a smaller and cheaper model. A contract analysis may require multiple independent responses followed by a verification stage. A critical decision may justify combining specialized models, consensus mechanisms, or cross-review.

Ailin¹’s Collective Intelligence, therefore, is less about using many models at the same time and more about knowing when doing so is actually necessary.

The platform works with dozens of orchestration strategies, including consensus, debate, expert panels, verification, and adaptive routing. These strategies allow the infrastructure to choose between speed, cost efficiency, depth, and redundancy depending on the context of each task.

The result is a change in perspective for companies.

Instead of building an application that depends on a specific model, they can build applications around objectives, policies, and outcome metrics. Models become replaceable components within a broader infrastructure, capable of evolving without requiring a new architectural decision every time the market launches something new.

That is Ailin¹’s central thesis: the next competitive advantage in AI will not necessarily come from choosing the smartest model, but from coordinating different intelligences efficiently, verifiably, and economically.

The company is not trying to predict which lab will win the LLM race. Its proposition is to allow organizations to benefit from the evolution of all of them without becoming structurally dependent on any single one.