# Lets White Paper 2026 - **Status:** Updated translation draft - **Last updated:** 2026-05-18 - **Source manuscript:** `docs/ru/lets_white_paper_2026.md` - **Primary audience:** users, creators, partners, investors, contributors - **Positioning:** media-first social product with a community participation and protocol layer - **Historical bridge:** from `DAC` and token-first framing to social-first Lets, `Glints`, `DAO`, and the external `LEC` protocol layer This document is informational and describes a product direction. It is not an offer to sell tokens, investment advice, a promise of token value, or a commitment that any feature, payout, settlement, wallet, or protocol access will be available in any jurisdiction. --- ## Table of Contents 1. Executive Summary 2. Origins: How Lets Began 3. What We Learned Building It 4. What Lets Is Today 5. The Mobile Layer: Social Core, Glints and Decisions 6. Contribution, Reputation and Community Participation 7. The Role of LEC and the Protocol Layer 8. DAO, Stewards and Community Governance 9. Creator Economy, Monetization and Settlement 10. AI-Native Direction 11. Public Site, White Paper and Portal 12. Where We Are Going Next 13. Closing Statement --- ## 1. Executive Summary `Lets` began as a decentralized vision for a new kind of social network. The early white paper captured the original ambition of the project: to give users more control over their data and digital value, embed `LEC` into the participation economy, and describe the role of the community through the early `DAC` model. That early stage mattered. It defined the DNA of the project: respect for the user, a more honest model of participation, the connection between social product and economy, and the belief that the community should have a real role in the platform's development. But real product development made one thing clear: a token-first approach cannot be the center of a mass social product. People do not return to an app every day for a token as an abstraction. They return for content, communication, attention, relationships, self-expression, discovery, and the feeling of a living social environment. Today `Lets` is framed differently: it is a media-first social product with a deeper participation layer. The first experience is the social core: feed, stories, profile, messages, notifications, discovery, and communication. As people participate, they gradually encounter Glints, Decisions, contribution, reputation, community helpers, creator tools, and the external protocol layer. The key shift of the current stage is the separation of the internal participation layer from the external protocol layer: - Glints are internal in-app virtual items in the mobile beta. They show participation, support, and contribution inside `Lets`. - `LEC` is the external protocol / settlement / alignment layer for reviewed web, creator, operator, and ecosystem scenarios. Glints are not a user-facing rename of `LEC` and do not create an expectation of automatic conversion. They are a separate mobile-safe layer that makes participation understandable for ordinary users. `LEC` keeps its strategic importance, but its role becomes more precise: it belongs to protocol, settlement, creator alignment, treasury, and future reviewed web scenarios, not to the first screen of the mobile app. This white paper exists to define the mature model of `Lets`: social product at the center, Glints as an understandable participation layer, Decisions as a form of community voice, DAO as an institutional frame of accountability, `LEC` as an external protocol layer, and the public site and portal as a bridge between the mass product and deeper ecosystem access. ## 2. Origins: How Lets Began `Lets` was born from the belief that social platforms can be built differently. A user should not be only a source of data, attention, and content for a closed system. A user should have a digital identity, a history of participation, social relationships, and a way to influence the environment they help create. The early project was described as a decentralized social network where content, communication, advertising, rewards, community participation, and digital value were connected into one ecosystem. That is where `LEC`, Proof of Contribution, the advertising model, value distribution, and the early governance frame through `DAC` came from. The early white paper contained many ambitious ideas: ownership, value distribution, reward mechanics, on-chain infrastructure, community governance, and a more honest attention economy. Those ideas did not disappear. They became more precise after real development, mobile platform rules, user comprehension, compliance constraints, and the need to build a living social product rather than only an architectural promise. The new version of the white paper therefore does not cancel the earlier document. It clarifies it. `Lets` is not abandoning its original purpose. It is changing the order of disclosure: first an understandable social product, then participation, economy, and protocol layer. ## 3. What We Learned Building It The central product lesson is simple: if a social product cannot be understood in the first session, a deep economy will not save it. Complex architecture, token mechanics, governance, and rewards matter only when there is a product on top that people want to return to. The early token-first approach carried a strong idea, but it created the wrong entry point. It forced the user to understand the system before the user had felt the value. For a broad audience, that is too heavy as the first step. The second lesson concerns mobile platforms. App Store and Google Play rules require careful separation between in-app digital goods, virtual items, payments, blockchain scenarios, and external settlement operations. `Lets` therefore cannot show the same token/economy layer in every environment. The mobile app must be understandable, safe, and store-compatible. Deeper protocol scenarios must live separately, with the required disclosures, eligibility, jurisdiction, and role gates. The third lesson concerns DAO. Community governance should not begin with terminology. For an ordinary user, it is more important to understand what is being decided, why it matters, what happens next, and who is responsible. That is why the first interface layer should speak about `Decisions`, `Contribution`, `Community Helpers`, and public execution history. The term `DAO` remains important for strategy, documentation, and the protocol layer, but the user experience should not require DAO literacy. The main conclusion is that `Lets` becomes stronger not because it abandons depth, but because it stops showing all of that depth at once. ## 4. What Lets Is Today Today `Lets` is a media-first social product. Its main value is not in the token or a governance mechanic, but in the social core: content, communication, profile, relationship graph, discovery, and daily use. The social core includes: - `Feed` for everyday consumption and return; - `Stories` as a fast social layer; - `Profile` as an identity surface; - `Explore` and search for discovery; - `Chat` for direct communication; - `Notifications` as a unified event center; - social graph through follows, friends, and privacy. On top of that foundation sits the second layer: Glints, rewards, support, Decisions, community participation, creator tools, monetization, advertising, and protocol integration. This layer strengthens the product, but does not replace it. The current identity of `Lets` can be described as: > `Lets` is a social network where people's contribution becomes visible, participation gets a clear form, and the community gradually gains more ways to influence product development. This framing matters because it explains the project without starting from blockchain vocabulary. A user can come to `Lets` as a social app. A more engaged participant can later open Glints, contribution, Decisions, community helpers, creator tools, and eventually the external protocol layer. ## 5. The Mobile Layer: Social Core, Glints and Decisions Mobile `Lets` must remain simple at the first level. That is why the mobile beta is built around a store-safe layer: - `Glints`; - `Contribution`; - `Decisions`; - `Support`; - `Community Helpers`; - readable activity history. Glints are internal in-app virtual items that live inside the `Lets` beta. They can reflect participation, support, and useful actions. They can be used in person-to-person support and optional support for community decisions. But they are not cryptocurrency, have no in-app market price, are not sold, withdrawn, exchanged, redeemed, or converted into `LEC`. Beta Glints do not create any present or future entitlement to `LEC` or any other asset. This separation is necessary not only for compliance. It also makes the product easier to understand. The word `Glints` does not require a user to understand blockchain, wallets, gas, networks, staking, or exchange rates. It describes a simple product idea: inside `Lets`, there is a sign of participation and support. `Decisions` are the user-facing form of community voice. In the mobile beta, decisions must be understandable as a social and product process: - what is being discussed; - what the options are; - how to vote; - what the community chose; - what happens next; - who is responsible for the next step. Store-safe decisions use one user, one vote. Optional Glints support shows that a topic matters to a participant, but does not change the result, vote weight, percentages, quorum, or feature access. This is a core boundary: support does not buy influence. In the mobile product, `Lets` should not begin with a wallet. It should begin with the social experience. Glints and Decisions open as a natural extension of participation, not as a separate financial layer. ## 6. Contribution, Reputation and Community Participation One of the main ideas of the next stage of `Lets` is making a person's contribution visible. Contribution in a social network is not limited to publishing a post. A person can create content, reply in discussions, support others, vote, help with rules, participate in community decisions, report problems, support the quality of the environment, or become useful in a local community. `Lets` should gradually collect this into a clear model: - what the user did; - why it counted; - how it relates to the profile; - what Glints or statuses the user received; - which Decisions the user participated in; - which ideas the user helped move forward. For the user, this should not look like a financial statement or a governance dashboard. It should be simpler: > `Your contribution shows how you participate in Lets: creating, discussing, supporting, and helping decisions move forward.` Inside the system, this can develop into Proof of Contribution, reputation signals, anti-farming controls, and future allocation logic. But the first layer must remain human. There is no need to explain ledger, scoring, snapshots, or token mechanics when the user simply wants to understand why an action was recognized. This model matters strategically. It separates `Lets` from tap-to-earn and points-farming projects. Participation in `Lets` should not be a mechanical farming loop. It should be tied to real social value, content quality, contribution to discussions, support for people, and community development. ## 7. The Role of LEC and the Protocol Layer `LEC` keeps an important role in the `Lets` ecosystem, but that role is now more precise. Earlier, `LEC` described nearly the entire participation and value distribution system. In the current model, `LEC` does not need to explain the whole product. It becomes a protocol / settlement / alignment layer for deeper scenarios: - creator and ecosystem settlement; - treasury and allocation logic; - external wallet flows; - legal-gated web access; - protocol proofs; - future DAO and ecosystem coordination; - alignment between creators, contributors, operators, and the broader network. The key principle is: > `LEC` is not the first user-facing language of the mobile app. It is the external protocol layer for scenarios where this is appropriate from a legal, technical, and product standpoint. This makes the product/protocol boundary clearer. `LEC` no longer has to carry the whole product meaning; it can remain an external protocol asset for legally reviewed scenarios. That is why Glints and `LEC` must remain separate: - Glints are the internal mobile-safe participation layer; - `LEC` is the external protocol / settlement layer; - there is no automatic conversion promise between them; - the mobile beta must not create an expectation of cash-out, market price, or token claim. In the future, `LEC` may be important for creator economy, protocol governance, settlement, treasury, external wallet, proofs, and ecosystem access. But these scenarios should open through a separate web/protocol layer, not through hidden complexity inside the mobile app. ## 8. DAO, Stewards and Community Governance Community participation has been part of `Lets` from the beginning. At the early stage, this idea was described through `DAC`. In the current and future model, the term is `DAO`, but it matters how this is applied. DAO in `Lets` should not be a decorative term, and it should not turn the user interface into a governance terminal. Its purpose is to give the community understandable ways to formulate proposals, discuss changes, vote, see accountability, and track execution. In mobile and consumer-facing layers, this idea opens through simpler concepts: - `Decisions`; - `Suggest an idea`; - `What happens next`; - `Public history`; - `Community Helpers`; - `Reports`. Beta DAO in `Lets` is hybrid advisory governance. This means: - the community discusses and votes; - results are an important product/community signal; - execution during beta remains operator-gated where safety, resources, legal review, or infrastructure access are required; - every action should have a public trail: what was decided, who is responsible, when it was updated, and what was completed. Before voting, a proposal should pass a readiness gate: what changes, why now, what resources are needed, who the accountable owner is, what the success metric is, what the risks/tradeoffs are, and what the expected execution path is. Without this, a proposal remains a discussion/readiness item, not a full Decision. `Community Helpers`, or stewards, are an important part of this model. They do not replace voting and do not receive automatic rights to govern the platform. Their role is to help ideas become clear, support discussion, check readiness, prepare reports, and make sure the result of a vote does not disappear without explanation. This DAO contour does not promise automatic on-chain execution, fully token-weighted governance, or treasury smart-contract control in beta. It builds a more mature institutional model of participation: understandable for people, verifiable for the team, and extendable for the future protocol layer. Legacy, operator-only, or future protocol governance paths may retain staking, snapshots, or weighted voting concepts, but these are outside the store-safe mobile Decisions model and must not leak into beta user-facing vote weight, quorum math, or decision outcomes. ## 9. Creator Economy, Monetization and Settlement The `Lets` economy should not be token-first. It should be built around sustainable product value. The first task of the economy is not to create a speculative story around a token, but to build sustainable value flows inside the product: - creator tools; - paid distribution; - boosts and promotion; - advertising; - support mechanics; - rewards history; - payout and settlement controls; - review, holds, anti-fraud, and reversals. Any paid digital boosts, promotion, subscriptions, creator perks, or in-app digital services offered in store-distributed mobile apps must use the applicable Apple or Google commerce path, unless a jurisdiction-specific approved entitlement or program applies. External web settlement and creator payout flows must not be promoted from the mobile app as a way to bypass platform payment rules. Creators should understand what they receive and why. Advertisers should understand what they pay for. Users should understand that Glints inside the mobile beta are not money, a token claim, or a way around platform rules. In the production model, it is important to separate: - internal participation signals; - creator earnings; - ad budgets; - platform revenue; - treasury or ecosystem allocations; - external settlement. Any future earnings, payouts, and settlement scenarios must pass through ledger, review, holds, and compliance checks. This is necessary for trust, safety, anti-fraud, and long-term resilience. For paid distribution and boost scenarios, the production economy should calculate value from validated net spend, not gross payment, after store/payment fees, tax/VAT, refunds, chargebacks, and reserve adjustments. Mobile digital payments should use store-compliant billing rails with explicit merchant-of-record, country availability, and reconciliation policy. `LEC` in this model may be connected to alignment, settlement, creator/ecosystem participation, and protocol-level coordination. But the launch model should not depend on speculative token appreciation. `Lets` should earn as a product, not as a promise of future market price. ## 10. AI-Native Direction The AI-native direction in `Lets` should be product-driven, not decorative. The first clear scenario is automatic translation of posts into the user's device language. For a social network, this is not only convenience. It removes language barriers, expands discovery, connects local communities, and makes content accessible beyond one language environment. AI can also strengthen other parts of the product: - concise summaries of long discussions; - help with drafting proposals for Decisions; - translation and adaptation of community reports; - moderation assistance; - detection of spam, farming, and low-quality reward abuse; - explaining to the user why an action counted as contribution. But AI should not replace the social experience. It should help people understand content better, participate more safely, and move more easily between languages, formats, and community contexts. For `Lets`, AI-native direction is about international reach, accessibility, and quality of participation, not hype. ## 11. Public Site, White Paper and Portal The next web layer of `Lets` should solve three different tasks. The public site is for orientation and conversion. It should quickly present `Lets` as an understandable social product with a deeper ecosystem layer: - what `Lets` is; - why it is not just another social network; - what Glints are; - how contribution works; - what Decisions are; - what role the community plays; - where the protocol layer appears; - why `LEC` exists; - how to read the white paper; - how to join the beta. The white paper is for depth: it explains the strategy, the history of changes, the role of Glints, `LEC`, DAO, creator economy, the AI-native direction, and the web/protocol layer. The portal is for role-based operations and accountability. It should not be mixed with the ordinary presentation page. It can contain separate surfaces: - Creator Portal for creators and monetization; - Community / Decisions Hub for Decisions, contribution, and public execution; - Operator / Partner Area for workflows, support, and reporting; - Protocol / LEC Zone for eligible participants and future settlement / external wallet scenarios. The portal should develop gradually. `v0` can be read-only and show public accountability: creator dashboard, contribution history, Decisions execution tracker, and steward reports. `v1` can add creator/community dashboards. `v2` can open role-gated operations. Deeper `LEC`, wallet, settlement, treasury, and protocol proof scenarios should live in a separate legal-gated zone. Gating may include role verification, jurisdiction checks, compliance review, and feature-specific eligibility. Public users should see explanatory, read-only content by default. It is important that the mobile app does not become a gateway to crypto operations. Mobile can remain simple and store-safe. The public site and portal can explain and reveal depth for those who need it. Store-distributed mobile builds should not include calls to action, deep links, webviews, external-browser prompts, or account flows that route users to `LEC`, external wallet, settlement, token purchase, or off-platform digital purchase flows. This web layer becomes the bridge between the mass user product and the long-term protocol vision. ## 12. Where We Are Going Next The next stage of `Lets` is not a return to the old token-first narrative. It is a movement toward a mature system where the social core, Glints, contribution, Decisions, creator economy, DAO, and protocol layer work together. The near-term directions are: 1. Strengthen the mobile social core: feed, stories, profile, explore, chat, notifications, privacy, and safety. 2. Complete beta QA so the product is stable, understandable, and store-safe. 3. Bring the product to a production-ready state: reliability, moderation, safety, analytics, user support, operating processes, and clear release criteria. 4. Develop Glints as an in-app participation layer without mixing them with `LEC`. 5. Make user contribution visible through profile, history, and contribution surfaces. 6. Strengthen Decisions with an execution tracker: what was decided, what happens next, what was completed. 7. Bring Community Helpers and working groups into a clear accountability layer. 8. Prepare the public site and white paper as the main project presentation. 9. Build the web portal for creator, community, and protocol roles. 10. Develop `LEC` as an external protocol / settlement / alignment layer. 11. Add AI-native capabilities, starting with automatic translation. The goal of this stage is to make `Lets` understandable to a broad audience and deep enough for those who want to participate in the development of the network at a higher level. ## 13. Closing Statement `Lets` began as an attempt to assemble a new kind of social platform: more honest toward the user, more open to participation, and deeper in its relationship to digital value. That goal has not changed. What has changed is the maturity of the project. `Lets` no longer needs to explain itself only through a token or abstract decentralization. Its strength is that it has a social core around which Glints, contribution, Decisions, community helpers, creator economy, AI-native capabilities, and the external protocol layer can gradually grow. The new model of `Lets` does not abandon the original vision. It makes that vision implementable. The ambition of `Lets` remains large: not simply to add rewards to a social app, but to change the relationship between content, participation, trust, and digital value. The difference is that this ambition now starts with a product people can actually use. First, a person gets a clear social product. Then they see their contribution. Then they participate in Decisions. Then the community gains tools of accountability. Only after that does the deeper level open: creators, settlement, `LEC`, treasury, proofs, and protocol access. This is how `Lets` can become not another app and not another token story, but a mature social platform where people's participation gradually becomes a visible, verifiable, and useful part of the shared system.