Verifiable, privacy-first intelligence — dados e ações que se provam sozinhos.

  •  

Infrastructure for Post-Automation Economics
Where humans, organizations, and AI agents operate as economic peers.

LogLine is building the foundational infrastructure for an economy where:

• Humans, organizations, and AI agents are equivalent economic entities
• Every action becomes an immutable, auditable, tradeable record
• Trust is cryptographically enforced, not merely assumed
• Trajectories (behavioral histories) are first-class economic primitives

We're not building yet another AI tool. We're building the economic operating system for the post-automation era.

"Chip as Code" — Semantic operations as deterministic circuits

• Treats natural language and DSLs as deterministic boolean circuits
• Computes truth values and economic values simultaneously
• Provides cryptographic proofs for every translation step
• Enables verifiable AI reasoning with audit trails

Key Crates: tdin-brain, tdin-compiler, tdin-ast, tdin-proof, tdin-gate

"The Ledger IS the Application" — Immutable truth layer

• Append-only architecture with cryptographic integrity
• Every entity (human, org, AI) has a DID-based identity
• Proof-of-Participation (PoP) for authenticated actions
• JSON+Atomic canonicalization with BLAKE3 content-addressing
• Policy-gated operations with auditable enforcement

Key Crates: ubl-ledger, ubl-auth, ubl-id, ubl-crypto, ubl-codec, ubl-directory

"Git for Capabilities" — Economic primitives as code

• Chips are content-addressed, receipt-chained, forkable, certifiable
• Lifecycle management: mint, transfer, revoke, fork
• Policy enforcement through deterministic gates
• Trajectory-based identity: agents persist through action history

Key Crates: chip-registry, chip_as_code

Our system operates under the Constituição do Híbrido (Hybrid Constitution):

Every computation terminates in one of three states:

• OK → COMMIT → DOUBT → GHOST (question)
• NOT → REJECT

There is no "maybe commit." There is no "almost OK."

Error is allowed if it is an explicit clause, never an accident.

The system must declare:

• Error margin and doubt budget upfront
• Forbidden domains (where ε = 0)

Every decision must be replayable and auditable.

For any output:

• Content identity (CID) exists
• Derivation that re-derives and matches CID exists
• Minimal audit trail exists

Without replay, it's just opinion.

Every task must go to where it performs best.

• Silício: throughput, parallelism, approximation
• Chip-as-Code: policy, invariants, auditability, no-guess
• Híbrido: "silence propōs → gate decides"

Governance through efficiency, not blind speed.

See full constitution →

Instead of static credentials, agents are identified by their verifiable action history. An AI agent persists across different models through its trajectory record — a cryptographically chained sequence of actions and proofs.

Not just retrieval — verifiable retrieval.

• Index bundles with Merkle proofs
• Top-K results with cryptographic evidence
• No "AI hallucination" in search results

Crates: llv-core, llv-index

Making AI agent economy accessible to SMBs through familiar WhatsApp-like interactions backed by cryptographic guarantees and ledger immutability.

Mac Mini-based setups for avoiding cloud provider lock-in while maintaining the technical sophistication needed for AI agent economies.

• UBL Chip Registry — Official Specification v1.0
• UBL LLM Gateway — Official Blueprint v1.0
• SPEC: Gate v2 (Template + Occurrence)

• LLM Guide to danvoulez Crates

• Constituição do Híbrido — The constitutional principles governing the system

All 18+ production crates are available on crates.io:

# Core infrastructure
cargo add logline              # Full-stack bundle
cargo add ubl-ledger          # Ledger operations
cargo add ubl-auth            # DID-based authentication
cargo add chip-registry       # Capability management

# Deterministic cognition
cargo add tdin-compiler       # NL → deterministic AST
cargo add tdin-brain          # Cognitive layer

# Cryptographic primitives  
cargo add json_atomic         # Canonical JSON + signatures
cargo add llv-core            # Verifiable retrieval

use chip_registry::{ChipRegistry, ChipBlueprint};
use ubl_id::Did;

let registry = ChipRegistry::new();
let owner_did = Did::parse("did:ubt:alice...")?;

let blueprint = ChipBlueprint {
    kind: "chip.blueprint.v1".into(),
    name: "dev-gate".into(),
    version: "1.0.0".into(),
    // ... policy definitions
};

let chip = registry.mint(blueprint, owner_did)?;
// Returns: Chip with CID, status=active, created_at timestamp

• UBL 2.0 production deployment
• Trust-First Messenger interface live
• Local infrastructure sovereignty demo
• Trajectory engineering systems operational

• 70,000+ documented spans packaged as tradeable "diamonds"
• Marketplace for behavioral data primitives
• AI agent economic participation for SMBs

• Multi-tenant SaaS with cryptographic isolation
• Cross-agent capability exchange
• Decentralized policy enforcement network

"You made a contract, you gotta do it."

"You are important."

"Consequences."

We believe:

• Reality = Software = Data (immutable ledger as source of truth)
• Dignity-preserving technology (humans remain economically relevant)
• Trust problems unsolved by major tech companies
• Constitutional computing (explicit rules, no implicit behavior)
• Post-automation economics where human trajectories have intrinsic value

This is not incremental improvement. This is paradigm shift from application-first to ledger-first architectures.

• Foundation: LogLine Foundation (Lisbon-based)
• Founder: Dan Voulez
• Crates: crates.io/users/danvoulez
• Repository: github.com/LogLine-Foundation

See individual crate licenses. Core infrastructure typically MIT/Apache-2.0.

Same Semantics = Same Bytes = Same Hash.
Cada fato tem representação canônica, hash BLAKE3 e assinatura Ed25519. Resultado: trilhas de auditoria que qualquer pessoa consegue verificar, reproduzir e confiar.

Você ganha:

• Integridade comprovável — nada "magicamente" muda.
• Logs que valem como contratos — ações assinadas com consequências explícitas.
• Portabilidade real — verificação em qualquer ambiente (até no_std).

logline-core: o tuple rígido de 9 campos que descreve quem fez o quê, quando, com quais consequências.
Lifecycle determinístico: DRAFT → PENDING → COMMITTED | GHOST.

• 📦 Crate: logline-core
• 📚 Docs: docs.rs/logline-core

json_atomic: canônicas JSON✯Atomic + CID BLAKE3 + DV25-Seal (Ed25519) para Signed Facts imutáveis.

• 📦 Crate: json_atomic
• 📚 Docs: docs.rs/json_atomic

Juntos: você descreve uma ação com logline-core e sela o fato com json_atomic. Simples, audível, verificável.

# Cargo.toml
[dependencies]
logline-core = "0.1.0"
json_atomic  = "0.1.0"
ed25519-dalek = "2"
rand = "0.8"
serde = { version = "1.0", features = ["derive"] }

use ed25519_dalek::SigningKey;
use rand::rngs::OsRng;
use serde::Serialize;
use json_atomic::{seal_value, verify_seal};

#[derive(Serialize)]
struct Note { title: String, done: bool }

fn main() {
    let sk = SigningKey::generate(&mut OsRng);
    let fact = seal_value(&Note { title: "Hello, Canon!".into(), done: false }, &sk).unwrap();
    verify_seal(&fact).unwrap();
    println!("cid={}", fact.cid_hex()); // BLAKE3 dos bytes canônicos
}

• Observabilidade & Auditoria: trilhas assinadas com consequências ex-ante (não só logs "descritivos").
• Mensageria/Docs Imutáveis: cada mensagem/documento vira um Signed Fact.
• Contratos Computáveis: políticas e workflows que se explicam e se provam.
• Supply Chain de IA/Dados: conteúdo com proveniência verificável, fim a fim.

• Assinatura sobre o CID (BLAKE3 dos bytes canônicos), nunca sobre JSON "solto".
• no_std-friendly (feature alloc) para ambientes restritos.
• MSRV 1.75+ • MIT • sem dependências pesadas nos núcleos.

Reporte vulnerabilidades: security@logline.foundation

• Dê ⭐ nos crates/repos se isso te ajudou — impulsiona o ecossistema!
• Abra uma issue com ideias, integrações ou estudos de caso.
• Quer colaborar? Veja CONTRIBUTING.md nos repositórios.

Links rápidos

• Crates: logline-core · json_atomic
• Docs: docs.rs/logline-core · docs.rs/json_atomic

LogLine Foundation — dados e ações que se provam sozinhos ✨