Start with one team
and one app.
Run AppOS locally, learn the platform boundary, then choose a small app to pilot with a real team.
Choose a problem
someone wants to solve.
Find a team with a clear request, such as a pricing calculator, a registration flow or a small approval workflow, and an owner who will use the app.
Agree what it needs to access, who may use it, what a correct outcome means and who is responsible after it ships. Start with capabilities the platform already provides.
Build AppOS
from the source.
The native shell and CLI require Rust 1.100 or later. Add the Wasm target for Rust apps.
git clone https://github.com/StephanSchmidt/appos.git
cd appos
rustup target add wasm32-wasip2
cargo build --release
export PATH="$PWD/target/release:$PATH"Run make for the repository’s default builds and checks. The README documents additional language-specific requirements.
TypeScript apps require Node.js 24+ and Zig. Zig examples use Zig 0.17. Java apps require a JDK 21+ and Maven. Start with the Rust scaffold to keep the first pilot simple.
Start with a working app.
Make it your team’s.
appos new events --group Marketing
cd events
appos devOpen http://127.0.0.1:8080/events. Changes rebuild and reload. The local development shell runs open on localhost.
Give your agent the problem and tell it to use the AppOS CLI. appos guide explains the contract; appos lists the available commands.
Use appos new events --ts or appos new events --java for those scaffolds. The Zig example is available to copy and explore.
Use it.
Exercise the edges.
Hardening means checking the app before it goes live and fixing what the check finds. Click through every page in appos dev: each request that works becomes a starting point for the review. Install appfuzz 0.8.1 or later, one way to automate the app review (why). appos review builds the app, writes appfuzz’s files and prints the command that runs the review:
appos review
cd appos-data/review && appfuzz --human review --plan plan.jsonRead the findings and fix the issues. A completed review is evidence from the scenarios explored, not a guarantee that your business rules are right.
The review is currently a separate step. A mandatory automatic appfuzz gate on every deployment remains a future integration.
Give the app
a shared home.
For a local platform exercise, start the shell in another terminal. Run this from the AppOS repository so risk.toml is available:
appos-shell --name pilot --addr 127.0.0.1:8081 --risk risk.tomlWithout a sign-in configured, the shell stays on this machine and prints a link that signs you in as admin. Open it, then make a token at http://127.0.0.1:8081/admin/token. From your app directory, connect with that token and deploy:
appos login http://127.0.0.1:8081
appos deploySet both owner and group in app.toml; deployment requires them. Visit the shell’s admin screen to inspect the app and its versions.
For a pilot other people use, give the shell a sign-in and a policy:
appos-shell --name pilot --addr 0.0.0.0:8080 --platform-addr 10.0.0.5:9090 \
--risk risk.toml --auth auth.toml --policy policy.csvauth.toml names how people sign in: OIDC, a proxy’s headers or a sign-in plugin. policy.csv says who may use which app and grant, and who is an admin. Start narrow: the pilot team, its app, and the grants it needs.
Keep the platform API on an internal address with --platform-addr. Behind a proxy, give --origin the address people use.
Prove the operating model.
- Can the team change and ship its app without engineering adopting its source?
- Are app capabilities and user permissions appropriate?
- Can engineering see the owner, grants, versions and failures?
- Can the company roll back or stop the app?
- Who takes responsibility when the original creator moves on?
- Who does the gardening, such as running
appos auditevery day?
Use what you learn to improve the shared platform.
NEXTAfter the pilot.
Give the next team
the same path.
Learn how the platform contract works, then run the next pilot with another team.