Value Systems And Policy Packets

Everyone carries rules about what matters more than what: liberty over safety until the harm is proven, equal treatment over efficiency. Most people never write those rules down, so nobody can apply them but the person holding them. A value system is those rules written down in a form software can act on, and a policy packet is that same file handed to another citizen who wants to reason the way you do.

Your rules, principles and priorities sit in one file you own, the Apply surface reasons a situation against them and shows which rules fired, and publishing sends a self-contained copy out under your verified name for another citizen to import.

What it does

A value system is a named, versioned record with three blocks in it, and the three map onto how a person actually reasons.

• Ordered rules are the this-versus-that logic. Each one reads when a named conflict arises, prefer this side, unless a named exception holds. Each carries a weight from 0 to 1 for how strongly you hold it, and a rationale in your own words. They are read top down, and the first rule that matches without its exception firing is the one that decides.
• Standing principles are unconditional. They are not comparisons but statements a recommendation is not allowed to violate.
• Ranked priorities are a plain list, most important first. They settle a conflict no explicit rule covers.

Everything except the name has a default, so a value system holding one rule is valid from the moment you save it. You can keep several, one for civic questions and one for economics, and choose which one judges what.

The Apply surface is what the structure is for. You type in a situation and get back a recommendation reasoned from your own rules, with the firing chain shown: which rules matched, which exceptions applied, which priority broke the tie. It never arrives on its own, so you can say the software read your rules wrong, or that the rule was wrong.

None of that is gated. In Individual Mode there is no account and no server. Authoring, editing, importing and applying all happen in a flat file on your own disk, and this is one of the four pillars a citizen can complete end to end without ever signing in.

Publishing is the one act that crosses out of your own tree. A finished value system becomes a policy packet: a self-contained file another citizen's copy of the software can read, stamped with who published it and when. That stamp is why publishing, and only publishing, requires a verified identity; the local default user is refused there. The packet caches under the author's name inside the importer's own files, so it can be weighted by how far that person trusts the author. An imported packet is read-only reference: viewable, applicable, or cloneable into an editable copy of your own, and re-importing refreshes only that one cached file.

The goal it serves

This is the movement's answer to being told what to think. The normal arrangement is that somebody in Washington, a media outlet, or an interest group with a budget decides what a reasonable position is, and citizens are handed the conclusion. Here you state the rules, and the software works out what follows.

It also answers a scale problem, and that scale problem is what makes capture cheap. There is far more legislation, spending, and procedure than any working person can read, so the reading gets done by paid staff who do not work for you. Rules written down once can be applied across more material than you could review by hand, the same way every time. That is the discipline that makes a recorded decision worth anything.

Then it makes ethics shareable the way software is. Somebody who has thought hard about a domain publishes their reasoning as a packet, and a citizen who trusts that person starts from considered rules instead of a blank page, then edits them, because the clone is theirs. That builds shared standards from the bottom instead of having them issued from the top, and it is why the author's trust score travels with the packet.

What keeps it honest

The feature applies your rules. It does not supply them. An empty value system produces nothing, and there is no house position underneath the one you wrote. When a recommendation is wrong, the fired rules are on the screen and the fault is locatable: in the rule, in its weight, or in the match.

Three limits are deliberate:

• A value system judges a situation, never a person's record. It is not an award, and nothing it produces feeds any award published about a politician. Those come from evidence about a named officeholder; this is your own reasoning about a question.
• The author's name stays on an imported packet. The original is never silently changed, and editing means cloning first.
• The build state is stated plainly. The Apply step today runs a deterministic rule matcher inside the app rather than a language model, and it reports that. Carrying an applied result into a decision's record is specified and not yet built.

Works with

• Decisions, Areas And Communities — a decision names the value systems that judged it, so the rules and the answer stay attached to each other.
• The First-Principles AI Check — that check tests whether a chain of reasoning holds on its own terms; your value system supplies which way you lean when it comes down to a preference.
• Citizen Votes — a position you reasoned out counts for more once it is cast, rather than kept in a file.

Where to go next

• Values — Pillar 3 in full: writing your rules down, and what the platform will not do with them.
• Policy packets — the publish and import path, and exactly what travels inside a packet.
• Communities — where individual positions get pooled into a community position, and where a shared packet does the most work.
• Great American Ethics — the standard this feature is one small instrument for restoring.
• Get Started — run it on your own machine and write your first rule. No account required.