Most teams start with prompts and tools. That is usually the wrong starting point. The better move is to build an operating system first, then layer agents into it.

This framework is adapted from John Cutler's basics-first product philosophy. This is my translation of that approach for agent-native teams.

How it works

The system runs on eight basics. Together, they create one loop: direction -> bets -> execution -> learning -> improvement.

1. Charter and mission

Define whose life you are improving, what you care about, and the principles you will not break. This prevents agents from optimizing for the wrong thing.

2. Strategy

Set one clear strategy. If your strategy tries to satisfy everyone, agents will generate broad but low-leverage output.

3. Models

Use one or more models to connect strategy to action. Models turn abstract goals into concrete decision rules agents can follow.

4. Roadmap of bets

Keep a rolling one-year roadmap, but fill it with opportunities and bets, not fixed solutions. Bets let you learn fast without pretending certainty.

5. Bet artifacts

Each active bet needs a one-pager (or parent doc), research notes, learning backlog, core team, extended team, and an advocate. This is the minimum context package for reliable agent execution.

6. Metrics and goals

Track both persistent input metrics and bet-specific metrics. Input metrics keep long-term direction stable, while bet metrics tell you if this specific experiment is working.

7. Kickoffs and learning reviews

Kickoffs align everyone before work starts. Learning reviews force evidence-based decisions during and after execution.

8. Continuous improvement

Run small process experiments every month. Improve the system itself, not just the outputs it produces.

How to use it

Step 1: Set up the operating layer

  1. Write a short charter and mission.
  2. Write one clear strategy statement.
  3. Create 1-2 models your team will use for decisions.

Step 2: Build your bet system

  1. Create a 12-month roadmap with 3-6 active bets.
  2. For each bet, create the required artifacts before execution.
  3. Assign one advocate per bet.

Step 3: Run a weekly execution cadence

  1. Kickoff any bet moving to in-progress.
  2. Run weekly learning reviews for active bets.
  3. Update roadmap status using evidence, not opinion.

Step 4: Run a monthly improvement cadence

  1. Review process friction from the last month.
  2. Choose 1-2 small improvement experiments.
  3. Keep what works, delete what does not.

What this changes in practice

  • You stop confusing activity for progress.
  • You reduce context loss between humans and agents.
  • You make roadmap decisions with better evidence.
  • You compound learning week over week.

If you are implementing agents in a product team, start with this operating system first. Tooling gets better every month. Fundamentals still decide outcomes.

Credit: adapted from John Cutler's \"The Basics\" and his fundamentals-first approach to product work.