Prove One Agent Spend Lane in 5 Minutes — NORNR Quickstart

6 min read Original article ↗
NORNR mark NORNR Governed agent spend before money moves.
01 / Install Install one SDK

Use the hosted control plane first. No full local runtime required for this path.

02 / Create Pick one spend lane

Start with governed runtime or browser checkout governance. Name one owner, one counterparty scope and one default pack first. Add MCP control server only after the first scope-bound proof path is live. The lane matters more than the raw SDK surface.

03 / Inspect See approved, queued or blocked

The point is the decision before spend moves, not just the payment afterward.

Observe -> install -> prove

The first NORNR movement should feel calm.

Discovery should show one exposed path. Install should add one review boundary. Proof should show the same decision and packet right away. If a team has to invent the next step, the quickstart is still too abstract.

Observe

Name the first consequential path

Use Governance Audit, Shadow AI Discovery or the browser demo when the team already has code or behavior in motion.

Install

Add one calm boundary

Budget Shield, one wrapper patch, one MCP starter or one browser release path is enough for the first install.

Prove

Show the defended record immediately

The same first lane should already produce a buyer-safe packet, review reason and export path without a second explanation thread.

Outcome

What you get

  • Choose one real spend lane inside the NORNR control plane
  • Run one governed action against hosted policy, approval and proof flows
  • See the decision before any real spend moves
  • Leave with a buyer-safe proof trail a finance or risk lead can inspect without reading SDK docs
Hosted path

No full local stack required

These snippets use the hosted control plane at https://nornr.com. Start here, then connect an existing workspace, MCP client or finance workflow later.

Best fit now

Pick one first lane only

  • Governed runtime: prove one canonical controlled action
  • Browser checkout governance: hold risky click-through before checkout lands
  • Next package: MCP control server for Claude Desktop, Cursor or Agent Zero once one proof path is already live and owned
One-lane rule

Make the first lane boring before you widen it

  • One lane
  • One owner
  • One approved-for-this-scope counterparty posture
  • One packet family finance can read later
MCP next

Open one local tools lane

When one governed runtime or browser lane already makes sense, use the MCP control server to carry the same review and finance trail into Claude Desktop, Cursor or another local agent surface.

Buyer path

This quickstart works best for teams that already have one workflow close to real spend.

If you already have vendor actions, browser checkout or paid tool usage in flight, the fastest next step is to compare one owned lane against the canonical proof path.

Best now

Teams with one live lane

Use this quickstart when you can point to one spend lane that needs policy and review now, not just later.

Next step

Open the canonical proof path

Compare your workflow against NORNR’s buyer proof before you widen the rollout surface.

Read the proof page ↗

One-lane installer

Choose the first lane and let NORNR hand back the whole control shape.

Quickstart should behave like a control-plane installer, not a generic SDK demo. Choose one lane, one surface, one review owner and one scope-bound vendor fit, then keep the proof and finance path attached from the beginning.

Starter

Installable default

Default pack
Review path
What survives

    Install and share

    Once the first lane makes sense, use starters and free tools to keep rollout friction low.

    The quickest way to widen from hosted proof into a real team workflow is an installable default plus one public-safe artifact surface.

    Installable defaults

    Move from the planner into a real starter

    nornr init now opens generic runtime, OpenAI Agents, LangGraph, MCP and browser lanes with one scaffold and one default posture.

    Open starters ↗

    Free tools

    Test the outputs buyers will ask for before rollout widens

    Use the policy simulator, trust manifest verifier and finance packet previewer to make the first lane more legible before a wider rollout.

    Open free tools ↗

    Policy packs

    Import a named starting posture instead of writing rules from scratch

    Community policy packs shorten the path from first lane to a buyer-safe rollout because the review and threshold posture already has a legible starting point.

    Open community policy packs ↗

    Failure analysis

    Turn agent logs into one concrete NORNR fix path

    Use the post-mortem tool when you already have a loop, overspend or bad tool path and need to show exactly what policy, packet and review path were missing.

    Open agent post-mortem ↗

    Comparison intent

    Catch the moment a buyer realizes raw infra is not enough

    Use the comparison pages when the team already understands rails, wallet permissions, raw MCP tools or ad hoc approvals and needs the missing layer stated clearly.

    Open comparisons ↗

    SDK quickstart

    Install, pick one wedge, run one governed action.

    Pick one language, start with one canonical spend lane, and confirm NORNR returns a decision before money moves.

    01 Install the SDK package

    Start with the hosted path so you can validate behavior without a full local stack.

    02 Choose one canonical spend lane

    Start with governed runtime or browser checkout governance. Do not try to learn every surface at once.

    03 Inspect the returned control-plane decision

    Look for approved, queued, or blocked, then open the same trail in the control room and reuse it as the first buyer-facing proof path.

    npm install @nornr/sdk
    
    import { Wallet } from "@nornr/sdk";
    
    const wallet = await Wallet.create({
      owner: "research-agent",
      dailyLimit: 50,
      requireApprovalAbove: 20,
      baseUrl: "https://nornr.com",
    });
    
    const decision = await wallet.pay({
      amount: 12.5,
      to: "openai",
      purpose: "model inference",
    });
    
    console.log(decision.status, decision);
    pip install nornr-agentpay
    
    from agentpay import NornrRuntime
    
    runtime = NornrRuntime.create(
        owner="research-agent",
        daily_limit=50,
        require_approval_above=20,
        base_url="https://nornr.com",
    )
    
    record = runtime.execute(
        action_name="quickstart-model-call",
        amount=12.50,
        to="openai",
        counterparty="openai",
        purpose="model inference",
        callback=lambda: {"ok": True},
    )
    
    print(record.execution_status)
    
    if record.requires_handoff:
        print("Review in NORNR:", record.decision.approval_url if record.decision else None)
    elif record.execution_status == "completed":
        print("Intent cleared before spend moved.")
    else:
        print("Blocked:", record.to_summary_dict())
    Expected status

    How to read the result

    • approved: policy allows the spend immediately
    • queued: control routes the intent into review before spend can move
    • blocked: policy blocked the spend
    Next

    Where to go after first success

    • Connect an existing workspace with Wallet.connect(...)
    • Open the control room to inspect approvals, anomalies and evidence
    • Use the playground to walk through replay viewer and A2A escrow flows before wiring a live workspace
    • Move into wrappers, browser guards or MCP once the first lane is working
    • Expand only after the first decision path is defensible for a buyer or operator