Transparency

5 min read

Most platforms publish a privacy policy. A legal document designed to protect the company, written so no one reads it.

We publish proof.

Our One is open source. Every line of code is public. But open source alone is not transparency — not when 99.9% of people can't read TypeScript. So we built something else: a system that translates what the code does into claims anyone can verify.

This is not marketing. There are no badges, no certifications, no "trust us" labels. What follows are facts. Falsifiable, verifiable, checkable against the public repository.

Deep Dives

Each system has its own detailed page with the actual source code — every claim verifiable against the public repository.

How Your Brief Works — The complete algorithm. Three layers, all chronological, no ML. Every query shown in full.
How Ownership Stake Works — One input. Membership years. The entire stake system in 30 lines of code.

What We Prove

Every service in Our One's codebase carries constitutional annotations — structured tags that map code to the specific constitutional clauses it implements. These annotations are enforced by CI: the build fails if a service file is missing them.

On top of that, automated negative checks grep the entire codebase to prove the absence of things we promised you'd never find:

Zero machine learning models. No TensorFlow, no PyTorch, no scikit-learn, no ML library of any kind. Your feed is not shaped by a model trained on your behavior.

Zero engagement scoring. No database column named engagement_score, click_count, time_spent, or view_duration. We do not measure how long you look at something.

Zero tracking or analytics SDKs. No Google Analytics, no Mixpanel, no Segment, no Hotjar. No tracking pixels. No behavioral analytics of any kind.

Zero IP address logging. Your IP address is used for rate limiting (to prevent abuse) and immediately discarded. It is never stored, never logged, never associated with your account.

Zero advertising infrastructure. No ad server, no auction system, no bidding, no ad network SDK. There is nothing to sell your attention to.

Zero A/B testing frameworks. No Optimizely, no LaunchDarkly, no GrowthBook. We do not experiment on you without your knowledge.

No connection request system. Follows are unidirectional. You follow someone; they don't need to approve it. There is no "pending" state designed to create anxiety.

Anyone can verify these claims in 30 seconds by searching the public repository.

How Your Brief Works

The Brief is the most constitutionally sensitive part of Our One. It is how content reaches you.

Read the full explanation with source code →

The short version: your Brief draws from three layers. You control the balance.

Circle — Posts from people you follow. Newest first. No ranking. No scoring.

Field — Posts matching your declared skills and Active Season. We match on what you told us, not what you clicked on. Ordered by recency.

Horizon — A small window of content from outside your graph. Every item is labeled with why it appeared. Capped at 15. Ordered by recency.

Every layer uses the same ordering:

// brief.service.ts — the entire "algorithm"
.orderBy(desc(posts.createdAt))

There is no secret sauce. There is no "engagement optimization." There is no model learning what keeps you scrolling.

How Search Works

Search uses PostgreSQL full-text search. All results are the same for all users — zero personalization. No sponsored results, no boosting based on popularity or engagement.

// search.service.ts, lines 73–98
const results = await db
  .select({
    id: posts.id,
    title: posts.title,
    body: posts.body,
    rank: sql`ts_rank(posts.search_vector, to_tsquery('english', ${tsQuery}), 32)`.as("rank"),
    author: { ... },
  })
  .from(posts)
  .leftJoin(userProfiles, eq(posts.authorId, userProfiles.userId))
  .where(
    and(
      eq(posts.isDeleted, false),
      sql`posts.search_vector @@ to_tsquery('english', ${tsQuery})`,
    ),
  )
  .orderBy(sql`rank DESC`)
  .limit(limit);

That is the complete post search. ts_rank is PostgreSQL's built-in relevance scoring — it measures how well the document matches the query, nothing else. No user behavior. No popularity. No personalization. Everyone sees the same results for the same query.

People search adds trigram similarity for fuzzy name matching:

// search.service.ts, lines 172–175
rank: sql`GREATEST(
  ts_rank(user_profiles.search_vector, to_tsquery('english', ${tsQuery}), 32),
  COALESCE(similarity(${userProfiles.username}, ${query}), 0)
)`.as("rank"),

No promoted profiles. No "people you may know" based on behavioral inference.

How Ownership Stake Works

Your stake is how many years you have been a paying member. That is it.

Read the full explanation with source code →

Nothing else earns stake. Not posting. Not voting. Not completing your profile. Not endorsing anyone. Your cent a day is your stake.

// stake.service.ts, lines 46–55
const endDate = Math.min(Date.now(), profile.paidThroughDate.getTime());
const rawDays = Math.floor(
  (endDate - profile.joinedAt.getTime()) / (1000 * 60 * 60 * 24),
);
const pausedDays = profile.pausedDays ?? 0;
const activeDays = Math.max(0, rawDays - pausedDays);
 
// 1 stake immediately on payment + 1 per completed year
return Math.floor(activeDays / 365) + 1;

Three fields. One formula. No hidden state. Any member can compute their own stake from their profile data.

How Governance Works

Proposals go through two phases: 7 days of discussion, then 7 days of voting. Vote weight equals your total stake (membership years). Quorum is 15% of total system stake. Standard proposals pass at 50%, constitutional amendments require 75%.

// governance.service.ts, lines 32–36
const DISCUSSION_DAYS = 7;
const VOTING_DAYS = 7;
const QUORUM_THRESHOLD = 0.15;        // 15% of total stake
const STANDARD_PASS_THRESHOLD = 0.5;
const CONSTITUTIONAL_PASS_THRESHOLD = 0.75;

The finalization check — every variable is visible, every threshold is a constant:

// governance.service.ts, lines 242–252
const totalVoteWeight = proposal.votesFor + proposal.votesAgainst;
const quorumMet = totalVoteWeight / totalSystemStake >= QUORUM_THRESHOLD;
 
const passThreshold =
  proposal.proposalType === "constitutional"
    ? CONSTITUTIONAL_PASS_THRESHOLD
    : STANDARD_PASS_THRESHOLD;
 
const totalVotes = proposal.votesFor + proposal.votesAgainst;
const passed = quorumMet && totalVotes > 0 && proposal.votesFor / totalVotes >= passThreshold;

Delegation is supported and revocable. All vote records are stored and queryable.

How We Built This System

The transparency system has four layers:

Constitutional annotations — Every service file has structured JSDoc tags mapping it to constitutional clauses. These live in git; every change is tracked.
Compliance manifest — A JSON manifest auto-generated on every CI run, cataloging every module and its annotations. If a service file is missing annotations, the build fails.
Negative checks — Automated grep-based proof of absence. The checks run on every pull request and push to main.
Transparency reports — Periodic reports that verify annotations match actual code behavior, citing specific file and line numbers. Generated by AI (Claude Code), always published alongside the commit hash so anyone can verify.

The methodology is published in full at docs/transparency/methodology.md in the repository.

What We Do Not Claim

We do not call this an "audit." That word implies third-party verification, and this is self-assessment. We do not use trust badges or certification labels. We do not claim this system is perfect.

What we claim is that every statement on this page is a verifiable fact. If any claim is wrong, you can check it yourself against the public repository, and you can hold us accountable.

That is the standard we are trying to set. Not promises. Proof.