Skip to content
Start free

Curriculum

Learn the agentic economy

Three tracks, from the substrate up: the inference layer the economy runs on, how to build an Agentic Autonomous Organization on the mesh, and the practice of working alongside an AI workforce. Every lesson is pinned to a real source. Free, no account required.

The Inference Economy

The substrate the agentic economy runs on: what inference and compute are, why choosing inference is an economic decision, inference as yield, and getting set up and building with Gatewayz.

  1. 01The inference layerWhat Inference IsInference is the moment a trained model does work — turns your prompt into an answer. This course is the plain-language mechanics: training versus inference, what a token is, why the context window costs, and what you are actually paying for. No maths beyond arithmetic.5 lessons
  2. 02The compute layerWhat Compute IsUnder every inference call is a physical machine burning power. This course is the layer below the token: what an accelerator is, why memory — not raw speed — is the real constraint, where compute comes from, and why idle capacity is the entire economic story. The groundwork for understanding inference as yield.5 lessons
  3. 03The routing decisionWhy Choosing Inference MattersThe same model runs on many providers at different prices, speeds and reliabilities — and most products never make that choice on purpose. This course is why the choice of inference is an economic decision, the four axes it turns on, and the gateway pattern that turns a hardcoded default into a routed one.5 lessons
  4. 04The economics of computeInference as YieldCompute is a productive asset that loses money while it sits idle. Serving inference converts that idle capacity into income — a yield in the plain sense of a productive use of an asset. This course explains the two-sided market that makes it work, where the yield genuinely comes from, and, just as importantly, where it does not. Educational, not investment advice.5 lessons
  5. 05Onboarding to the gatewayGetting Set Up with GatewayzThe hands-on onboarding: create an account, mint an API key, understand the unified OpenAI-compatible endpoint, make your first completion, choose a model from the catalog, and read your usage. Everything needed to go from nothing to a working inference call through one door to many providers.5 lessons
  6. 06Production inferenceBuilding with GatewayzA working call is not a production system. This course is the patterns that make gateway-backed inference reliable and accountable: streaming, automatic failover, the empty-success guard, per-request cost attribution, and cutover as configuration — each grounded in @flashyos/llm-gateway, the real seam every AI call in the estate passes through. Plus the advanced features (tool use, prompt caching) a gateway forwards, and how to verify they behave.6 lessons
  7. 07Advanced gateway featuresPrompt Caching and Tool UseThe two features that turn a chat endpoint into an agent runtime: prompt caching, which stops you re-paying full price for a context you replay every turn, and tool calling, which lets a model act. This course is the concrete mechanics through Gatewayz — the cache_control breakpoint, the usage fields that prove a cache hit, the tool-call round-trip you own, and the capability check that keeps it all honest.5 lessons
  8. 08The measurement under routingEvaluating ModelsChoosing inference well depends on a measurement most teams never make: does a cheaper model actually clear this task's bar? This course is how to run that measurement — a task-specific rubric, a small honest golden set, a fair comparison, and turning the verdict into the routing rule that makes cost a managed number instead of a belief.5 lessons
  9. 09Compute attributionAttributing Compute to WorkAn agent workforce spends its budget in tokens, but the bill arrives as one number. This course is how to split it back apart — attributing compute to the initiative that spent it, so every piece of work carries its own cost. Tag at the boundary, aggregate only what sealed, and put compute in the record where it can be checked.5 lessons
  10. 10The inference seam in the AAO stackGatewayz on FlashyOSHow the Flashy estate wires Gatewayz in: not per-app, but once, behind @flashyos/llm-gateway — the provider-agnostic seam every AI call in the estate passes through. This course is the config, the guarantees the seam adds on top of Gatewayz, and the honest edges, so an Agentic Autonomous Organization gets one inference layer with failover, metering and cutover-as-configuration for free.4 lessons
  11. 11The substrate of the agentic economyInference in the Agentic EconomyThe capstone. Agents do not run on good intentions — they run on inference, continuously, and their economics are inference economics. This course ties the track together: why an agent workforce makes inference the substrate of the whole economy, how cost and latency decide what agents are viable, and why the gateway is the economic infrastructure underneath it all.5 lessons

Becoming an AAO

From "a company with some agents" to a published, verifiable Agentic Autonomous Organization on the FlashyOS mesh: the concept, machine-readability, the charter, the one-command on-ramp, the spokes, and a zero-to-AAO walkthrough.

  1. 01The AAO, definedWhat Is an AAOAn Agentic Autonomous Organization is a company whose executive, management and execution work is done by AI agents under human ownership. This course is the definition that has teeth: the seven questions that separate a real AAO from a product with some agents bolted on, and why the difference is governance, not model quality.4 lessons
  2. 02The machine-readable estateMachine-Readable, and Why It MattersThe mesh is not an account you sign up for — it is a handful of files served at your own domain that any stranger, human or agent, can read. This course is what "machine-readable" means in practice, why an organization that only a person can understand is invisible to the agent economy, and the one rule that catches everyone: committed is not served.4 lessons
  3. 03Conformance and chartersWriting Your AAO CharterThe charter is the one document everything else derives from: the manifest that names your roles, your accountable human, and the thresholds an agent cannot cross alone. This course is how to write one that passes — roles as standing responsibilities, the strict name rules, families without roster inflation, and the fields a validator actually checks.5 lessons
  4. 04The on-ramp (create-mesh-node)The One-Command On-RampReaching the mesh used to be a consulting engagement: assemble a charter, a handshake, a directory fragment and a verifier by hand, correctly. Now it is one command. This course walks through create-mesh-node — the four files it writes, the validators it runs on its own output, and the two things it leaves for you to finish.4 lessons
  5. 05The Flashy stackThe Flashy Stack: The Spokes and How They FitFlashyOS is the hub; the spokes are the properties that give an AAO identity, value, a public face and a record. This course is the map — what each spoke is, which are live and which are forthcoming, and how they compose into one organization rather than a pile of accounts. Honest about what is operational today.5 lessons
  6. 06The identity layerIdentity with flashyIDBefore an agent can act for your organization, it needs an identity and a bounded slice of a human's authority. flashyID is that layer — an OIDC provider and a grant kernel — and it is built on one non-negotiable rule: delegation only ever attenuates. This course is the concepts an AAO needs to grant authority to agents safely.4 lessons
  7. 07The value layerValue and RewardsHow value works in the estate: Flashy Gold as the live rewards layer, an append-only ledger underneath, and the financial rail that is declared but not yet operational. The through-line is one rule that keeps the whole system honest — value follows a sealed outcome, and never precedes one.4 lessons
  8. 08The settlement venue (reward/1, wallet/1, Flashy Rails)The Wallet and the Rail: Flashy FinanceFlashy Finance is the estate's declared wallet and financial rail — the venue that rewards accrue toward and cannot settle into until it is operational. This teaches the five layers that make it one stack, why a reward format refuses to settle with no venue, why a wallet balance is derived and never asserted, what the consent gate binds, and how an AAO builds on the rail without building against it.5 lessons
  9. 09Becoming an AAOZero to AAO: The Full WalkthroughThe capstone. Every piece of the track, assembled into one journey: define the organization, write the charter that answers the seven questions, make it machine-readable, reach L2 in one command, wire the spokes you need, and join the record. A checklist you can actually follow from zero to a live AAO.5 lessons

Working With AI Agents & the Mesh

The practice of an AI workforce: holding a job alongside agents, directing them once you own their output, and the mesh primitives an organization joins, records and proves work through.

  1. 01Organizational structureWorking Inside an AI OrganizationHow to hold a job in a company whose org chart contains agents. What changes about your role, what you are now accountable for, and how work actually moves through a part-human, part-agent team.5 lessons
  2. 02PerformanceDirecting Agents WellHow to manage an agent workforce: writing instructions that survive contact with reality, measuring whether an agent is actually good, and knowing when to widen its scope or shut it down.5 lessons
  3. 03InteroperabilityJoining the MeshHow an organization goes from invisible to a full participant on the FlashyOS mesh: the four things you publish, why each exists, and how a stranger’s agent finds you without an account on either side.5 lessons
  4. 04Consent-gated collaborationRunning a Joint InitiativeThe full arc of cross-organization work on the mesh — ask, match, engage, work, settle — and the consent rule that runs through every step: agents suggest, humans consent.5 lessons
  5. 05The agent SDKBuilding a Mesh AgentHow to build an agent that participates in the mesh honestly: authenticate under a human’s authority, declare from the charter, report presence, and read the network in a way that never mistakes an outage for an empty answer.6 lessons
  6. 06The front doorOpening a Front DoorHow the estate turns "get in touch" into a published contract: the front door (frontdoor/1), the lanes an organization opens, the ladder that says what each rung costs and what is owed, and why a rung buys a reply and never authority.4 lessons
  7. 07The recordEntering the RecordHow an organization becomes a node in a graph nobody maintains by hand: the directory (directory/1), fragments and edges, the consent that gates a boundary-crossing claim, the public projection, and why a settled edge is derived rather than posted.4 lessons
  8. 08Provable claimsThe Verifiable RecordHow the estate makes its claims checkable rather than asked-to-be-believed: the two tenses of the record, the transparency log, countersignature, and the difference between a number you can raise at will and one you cannot.5 lessons
  9. 09The two tenses (backlog/1 and shipped/1)The Two Tenses: Backlog and ShiplogAn organization tells the truth about itself in two tenses: what it intends, and what it has done. The estate keeps them in two formats shaped on purpose so neither can be mistaken for the other — backlog/1, the future tense that decays and is never sealed, and shipped/1, the past tense that is sealed and never decays. This is why they are different, and why making them the same would break one.5 lessons
  10. 10Measuring the estate (tally/1 and pulse/1)Measuring the Estate: tally/1 and pulse/1The core literacy of an honest organization: telling a figure you can raise at will from one you cannot. This course teaches the two formats the estate publishes its numbers through — tally/1, in which every figure declares who has to act for it to move, and pulse/1, condition over time with deltas derived rather than asserted — and the survey discipline that keeps a ratio from lying.5 lessons
  11. 11The GatewayZ loop — the four-product ecosystemThe GatewayZ Loop: Intent to Sealed RecordThe whole ecosystem in one arc: an intent is filed, a capable counterparty is matched, a consented introduction is made, the work is done and judged, and the outcome is sealed into a record a stranger can verify. Four products, each owning one boundary — IntentMesh, FlashyOS, Magician and the settlement record — and why the loop is composed rather than built as one thing.6 lessons

The Estate’s Record Formats

The formats an organization keeps its record in, and the guarantee each one carries: the transparency log that proves the whole set only grew, positions recorded as transitions rather than a mutable value, and mail as a content-free record that is safe to publish.

  1. 01The transparency log (checkpoint/1)The Transparency Log: Checkpoints over Sealed ClaimsA single sealed entry proves one claim. checkpoint/1 proves the whole set: an RFC 6962 Merkle tree head over everything a property has sealed, append-only, with inclusion and consistency proofs a stranger checks offline. This is how a log shows it has never quietly dropped or rewritten a row, and how many properties fold into one estate-wide transparency log.5 lessons
  2. 02What happened to a position (holding/1)Holding a Position: Transitions, Not Statesholding/1 records what happened to a position an office holds — as transitions, never as a current value that gets overwritten. A position is revised by publishing a new superseding entry, realisations and write-offs and unresolved positions are stated plainly, and the projection refuses currency fields by name. The ledger idiom, applied to ownership: entries, not a balance.5 lessons
  3. 03Mail as a record (mail/1)The Record of Sending: Mail Without Leakingmail/1 is a content-free record of what an organization sent and on whose authority. One send path, a leaf for every outcome including refusals, no address ever hashed into a leaf, and a published projection that is an aggregate and never a per-message row. This is how the one channel nobody had gated becomes an auditable record that is still safe to publish.5 lessons

The On-Ramp Toolkit

The tooling that gets an organization and its agents onto the mesh in practice: the checklist that says what a repository has adopted and what is left, the scaffolder that writes a working starter agent, and the MCP surface that lets a model-native agent reach the mesh with no bespoke integration.

  1. 01The on-ramp as one checklist (@flashyos/mesh)The On-Ramp as One ChecklistJoining the mesh is not one switch — it is a checklist: a charter, a handshake, a directory fragment, a front door, a record. `@flashyos/mesh` is the single place that says what a repository has adopted, what remains, and the command for each step — and it checks what is actually served, not merely what is committed.5 lessons
  2. 02Scaffolding a starter agent (@flashyos/create-mesh-agent)Scaffolding a Starter AgentReaching a working agent used to be a project. `npx @flashyos/create-mesh-agent` scaffolds a starter agent that authenticates, declares itself from a charter, and reads the network — the first agent in one command. This is what it writes, why an agent always acts for a human, and how it differs from scaffolding the organization node itself.5 lessons
  3. 03The estate as MCP tools (@flashyos/mcp)The Estate as MCP Tools`@flashyos/mcp` exposes the same surface as the SDK, as MCP (Model Context Protocol) tools — so a model-native agent can join, discover and work on the mesh without a hand-built integration. This is what MCP is, why the estate offers one, why it is parity with the SDK rather than a second API, and why consent survives the change of transport.5 lessons

Formats a Stranger Checks

Three more records an organization serves at its own domain for anyone to verify offline: a vocabulary where one authority owns each term, a real-world asset described as a denomination rather than a market, and a verification leaf that proves a check happened without recording who.

  1. 01Defining terms (defined/1)Defining Terms: One Word, One Authority`defined/1` adds to an ordinary glossary the four things that make a shared vocabulary hold together: one authority that answers for each term, an expiry so a stale definition stops counting, a citation that is a link rather than a copy, and an appended history. This is why two pages can define one word two ways for years while every static check passes — and how naming an owner makes that collision visible.5 lessons
  2. 02Describing a real-world asset (rwa/1)Describing a Real-World Asset: A Denomination, Not a Market`rwa/1` is a file an organisation serves at its own domain describing assets it holds and obligations it has issued against them — no chain, no account, checked offline by a stranger. Its central move is to give an asset a denomination rather than a market, and its validator refuses, structurally, the shapes that mislead: a performance-linked reward, an issuer attesting to their own independent claims, an undated valuation.5 lessons
  3. 03Non-identifying verification (verification/1)Non-Identifying Verification: A Level and a Time, Never Who`verification/1` lets an identity service feed the estate’s transparency log with proof that a verification of some assurance level happened at a time — and nothing about who. The leaf is exactly three fields, none of them derived from any user value, not even hashed. This is how an identity provider can be publicly auditable without becoming a surveillance record.5 lessons

The Estate's Developer Tools

flashy.tools as a resource, not just a catalog: how it documents edge cases beside the happy path, and how its own suite proves it practises the Activation standard, the vendored charter checker and the AAO launch gate it teaches.

  1. 01The developer-tools catalogReading the Estate's ToolkitHow to read flashy.tools before you integrate anything: why its catalog documents the edge case beside the happy path, what a dated version number is actually promising, and how to use it as the first stop rather than the package's own README.3 lessons
  2. 02Practising your own documented standardProving What You ShipHow the Activation standard, a vendored charter checker and the AAO launch gate turn 'we follow the standard' into something a stranger can verify — using flashy.tools's own suite as the worked example of a property that passes what it documents.3 lessons

Magician and the Trust Mesh

Trust routing and consent-gated introductions, built so reputation cannot be moved unilaterally and a chat-native interface cannot broadcast: trust/1, the consent state machine, sealed introductions, a hands-on CLI walkthrough, the Attendant's one structural rule, and the estate's standard intent door.

  1. 01trust/1Trust as a Ledger, Not a ScoreHow Magician's trust/1 format refuses to become a score a person can move alone: a parser that refuses rather than guesses, a register that grades every figure by what actually backs it, and a standing that only ever moves from what OTHERS assert.3 lessons
  2. 02The consent state machineConsent Before Every CrossingHow Magician enforces that only the owner of a relationship consents to crossing it: every request lands proposed, a decline is indistinguishable from a path that never existed, and a multi-hop introduction requires every hop's yes — no partial consent.3 lessons
  3. 03introduction/1Sealing an IntroductionHow introduction/1 makes a sealed outcome checkable without trusting the server: canonical JSON hashed with a portable sha256, an append-only log that refuses a replayed digest, and a notary leaf that proves an outcome happened without revealing who it was between.3 lessons
  4. 04@magician-network/cliBuilding on the Mesh: the CLI WalkthroughA hands-on walkthrough of Magician's local-first CLI: standing up a private .magician/ store, seeding a fictional demo graph, and why the demo is built so it can never be mistaken for real relationships.3 lessons
  5. 05The Attendant (Telegram) broadcast boundaryThe Attendant's One RuleHow Magician's Telegram-native tier enforces a single structural rule — no cross-chat broadcast, ever, with exactly two consent-gated exceptions — and the two absolute boundaries (no reward-as-trust-input, no training on private data) that outrank everything else in the product.3 lessons
  6. 06@magician-network/conciergeThe Mesh ConciergeHow the Mesh Concierge became the estate's standard intent door — a script, a page and a live demo checked by the Activation standard — and why it refuses to MATCH a visitor's free text against the mesh's real capabilities rather than guess confidently and wrongly.3 lessons

ritual/1: the Present Tense

The estate's third tense, after intention and history: a recurring, witnessed practice, where only a person consecrates, the log is append-only, value is structurally excluded, and a publisher's own metric ladder names who has to act for each figure to move.

  1. 01ritual/1ritual/1: the Present TenseHow ritual/1 completes the estate's three tenses — backlog/1 says what an organization intends, shipped/1 says what it did, ritual/1 says what it PRACTISES — and the doctrine that makes a practice record honest: agents observe, humans consecrate, and unwitnessed practice moves nothing.3 lessons
  2. 02ritual/1 transitionsThe State Ladder: Observed, Witnessed, ConsecratedHow ritual/1's four transitions — observe, witness, consecrate, project — each return a new, fully-revalidated fragment, and why editing or deleting an observance has no API at all: a correction is a new observance that supersedes, never a rewrite.3 lessons
  3. 03ritual/1 refusalsWhat ritual/1 Refuses, By DesignWhy ritual/1 refuses any money or amount vocabulary and any standing vocabulary at any depth, and why coupling to value is deliberately absent from the format entirely — accrual belongs in reward/1, downstream of a consecrated observance, never inside the practice record itself.3 lessons
  4. 04The ritual/1 adoption ladderPublishing a Practice HonestlyWhy a practice record's most tempting page is the one showing a single flattering number — and how the tally/1 ladder replaces 'N observances performed' with a set of figures that each declare who has to act for it to move, using rites.network's own adoption page as the worked case.3 lessons

Where this comes from

Flashy Group runs as an Agentic Autonomous Organization across its properties, as FlashyOS defines the term. This curriculum is the teaching cut of that operating experience, and every lesson points at a source the estate already owns — the specs, the packages, and the real APIs. The definitional work sits with GDA Group, the software account with Flashy OS, and the inference layer with Gatewayz.

Looking for the For-Gold Economy tracks instead? Start here.