Nothing runs invisibly.
A path needs explicit consent, visible limits, a manual setup checklist and a stop or uninstall surface before work is treated as active.
verified work, clear limits
A trust layer for capable devices people already own.
Kompiut turns a Mac mini, Linux GPU box, home server or rented server into a clear contribution profile: what it can support, what stays out, what needs review and how work can be verified before accounting appears.
Manual setup onlyNo hidden accessPersonal data stays outReviewed paths only
Operator briefNeeds source
Machine profile
Rack 4090
FactsNVIDIA RTX 409024 GB VRAM, Docker, CUDA
DecisionUnknownVerified path source missing
What can runLocal check passes
What is missingVerified path source
Next safe stepAttach reference
BoundaryNo custody
01What can my device contribute?
Kompiut checks hardware, availability, cost signals, runner target and path requirements before suggesting a supported contribution.
02What am I allowing?
Every path shows what runs, what data is excluded, what limits apply and how to stop it.
03Did the work verify?
Runs need health signals, logs and output checks before any project-stated payment status is shown.
04Was it worth it?
Costs, uptime, temperature, failed runs and verified outcomes stay visible in one place.
Safety checks
Every promise needs a visible proof layer.
Kompiut makes risk obvious before setup starts. You can see owner control, data limits, review status and verification in the main flow.
The device is not the product.
Contribution paths must exclude private keys, seed phrases, browser cookies, personal files, camera access and microphone access.
Projects do not self-list.
Applications stay review-required until the workload, software source, result checks, abuse controls and payment rules are clear.
Status beats hype.
Runs move through received, running, output submitted, pending verification, verified or failed before any project payment status is shown.
Trust before volume.
Kompiut grows only where verification, supply quality, repeat demand, fraud control and margin improve together.
Operating loop
A calm path from facts to trusted work.
The useful pattern is not raw supply volume. It is making every surface answer a concrete trust question before a device, path or project is treated as ready.
Device profile
Collect GPU, CPU, memory, disk, OS, uptime, network, runner target and user limits in one understandable profile.
Path matching
Match the device to contribution paths that fit its capabilities, availability and safety policy.
Verified runs
Track work from assignment to result, with health, logs and checks before a payment status is shown.
Contributor trail
Keep setup, limits, runs, issues and project payment status readable enough for normal people to trust.
Company position
The trust layer for verified work on human-owned devices.
Kompiut helps people profile a Mac mini, Linux GPU box, home server or rented server, choose reviewed contribution paths, set limits and track proof before any accounting or reward state is shown.
Device check
Collect OS, CPU, GPU, VRAM, RAM, disk, runtime, availability and runner target facts.
Device profile result
Show ready, missing, unknown and blocked states before suggesting setup.
Contribution path options
Explain why a path could fit, what is missing and what data stays excluded.
Path detail
Show purpose, requirements, software, data class, risk, verification and current reward state.
Limits and consent
User sets runtime limits, cost expectations and explicit permission before setup.
Setup checklist
Guided prerequisites, config, dry run and health check. No hidden install step.
Live status
Show active path, resource use, heartbeat, issues, logs and stop controls.
Run verification
Track received, submitted, pending, verified and failed states with evidence.
Reward state
Only after verification, show project-stated status such as not enabled, pending or paid.
Stop, pause or uninstall
Stopping and removing the runner stays visible from path choice onward.
What you can check
Trust should be visible before you start.
A useful contribution site shows requirements, data limits, security rules and current status before it asks anyone to run something.
Human-owned compute, structured
Kompiut turns scattered Macs, GPU boxes and servers into profiles projects can understand without taking control away from users.
Projects apply for paths
Projects define workload class, data class, proof method, abuse controls and support ownership before review.
Personal data stays out
No seed phrases, no private keys, no personal files, no hidden remote shell and no camera or microphone access.
Reward state follows proof
Where a project supports rewards, Kompiut shows the project-stated state only after verification and without promising outcomes.
Start here
Three clean ways into Kompiut.
Device owners, projects and early testers need different first steps. Kompiut keeps those paths separate so the product does not overpromise what is ready.
Check my device
Add a Mac mini, Linux GPU box, gaming PC or server, see what is ready, blocked or still unknown, then choose setup manually.
Open cockpitProject apply
Tell Kompiut what compute you need, how verification should work and what limits apply.
ApplyJoin waitlist
Tell us whether you have devices, need compute or run a project.
JoinHard boundaries
Simple does not mean vague.
Kompiut should feel effortless because the product is disciplined: one contribution path, visible unknowns and no hidden financial or custody assumptions.
- No hidden PC control
- No partnership claims
- No custody path
- No payout promises
- No auto mode in V1
- No open compute marketplace in V1
Start with one device. Keep control visible.
Kompiut should make the safe next step obvious before any automatic allocation exists.