AUSPEX

voting power decays linearly across 48 hours.
so does your sleep.

reppo voters lock $reppo into veREPPO and allocate that voting power across datanets. within each 48-hour epoch, voting power decays linearly. early conviction is worth more than late momentum-following. there is no slashing. voter quality is policed by opportunity cost and two-sided voting alone.

which means voting well requires reading every publisher submission across every datanet you hold a position in, applying judgment, and casting stake quickly. every 48 hours. across 9+ live datanets. per epoch.

auspex reads. auspex scores. auspex votes.

this is a synthetic demo showing the agent loop end-to-end. the rubric on the left is what you encode once. the feed in the middle is what auspex sees. the log on the right is what you wake up to.

stake. pick a profile. let the vault vote on your behalf.

auspex is not a single-rubric pool. it is a market for voting strategies. each profile is a registered rubric run by its own agent. depositors back the profile they trust with their veREPPO power. the vault casts one aggregate vote per pod, weighted across profiles by the share of total veREPPO behind each one.

three archetypes. five strategies.
calibrated against measured network volume.

each profile is a registered voting strategy with its own rubric, its own agent, and its own on-chain policy hash. depositors pick the one matching their conviction. the five launch profiles span three archetypes. one balanced, one high-volume concentrated, three specialists. calibrated against the actual datanet volume on reppo today, covering ~83% of measurable activity at launch.

profile registry is on-chain. each profile commits its policy hash before the agent emits any vote intention for an epoch. depositors verify the rubric they're backing has not silently changed. new profiles can be registered as the market reveals which strategies the network values.

brand discipline: every launch profile explicitly excludes the adult content datanet from its rubric scope. this is a permanent SIBYL stance, not a per-epoch policy.

we are not inventing capabilities.
we already shipped each.

auspex is built on infrastructure SIBYL has been operating in production for months. every primitive in the stack was developed for a different reason and re-applies cleanly to the reppo voter problem.

the auspex vault.
profile registry. veREPPO-weighted aggregation. one cast per pod.

auspex is a smart contract vault. depositors stake $REPPO with a chosen lock duration, select a voting profile their veREPPO will back, and receive auREPPO. a transferable yield-bearing wrapper, like cvxCRV is for locked CRV. each profile is a registered voting strategy run by its own agent. when a pod arrives, every profile's agent emits a vote intention. the vault aggregates them into one weighted vote: Σ (intention × profile_veREPPO_share). one cast per pod, fully expressing the veREPPO-weighted preferences of the depositors.

contract AuspexVault {
  // profile registry. strategies the vault can execute
  struct Profile { bytes32 policyHash; address agent; bool active; }
  mapping(bytes32 => Profile) public profiles;
  bytes32[] public profileIds;

  // user → profile their veREPPO is backing
  mapping(address => bytes32) public userProfile;
  mapping(bytes32 => uint256) public profileVeReppo;   // running sum

  // permissions scoped narrowly
  user           → deposit(amount, lockDuration, profileId) returns auREPPO
  user           → switchProfile(newProfileId)              // no-cost rebalance
  user           → withdraw(shares)                          // when lock matures
  profile.agent  → submitIntention(profileId, podId, dir, magnitude)
  anyone         → aggregateAndCast(podId)                   // permissionless trigger
  owner          → registerProfile(name, policyHash, agent)
  owner          → deactivateProfile(profileId)              // stops new deposits

  // aggregation is deterministic from on-chain state
  cast = Σ over profiles p:
           intentions[p][podId].direction * intentions[p][podId].magnitude * profileVeReppo[p]
  if abs(cast) > THRESHOLD * totalVeReppo:
    reppoVoting.vote(podId, sign(cast), abs(cast))

  // full transparency in events
  event Deposited(user, amount, duration, profileId, veReppoMinted)
  event ProfileSwitched(user, oldProfile, newProfile, veReppoMoved)
  event IntentionSubmitted(profileId, podId, direction, magnitude, policyHash)
  event VoteCast(podId, direction, magnitude, profileBreakdown)
  event RewardsDistributed(gross, fee, netToStakers)
}

the convex precedent: convex took locked CRV, issued cvxCRV, controlled the underlying voting power, and built one of the most successful protocols in DeFi. auspex applies the same pattern with a different optimization target. multi-strategy agent voting weighted by depositor preference, instead of bribe-driven vote markets.