# Noorle — expanded product context

> Noorle is the Agent OS for autonomous work: a hosted runtime for agents, Programs, published Workflows, and MCP Gateways where every effect runs under identity, live authority, admission policy, budget, and a durable journal.

This file expands the product map in [llms.txt](https://noorle.com/llms.txt). It explains the platform vocabulary and operating model without duplicating the technical documentation. For implementation details and the complete page inventory, start with the [Noorle documentation index](https://noorle.com/docs/llms.txt), whose entries link directly to Markdown.

## What Noorle is

Noorle is the hosted platform where businesses and builders compose, govern, and run agent workforces for their own operations or as part of a product. Frameworks help agents think; an Agent OS governs what agents can do.

The platform has three ways to put work into the world:

- An **Agent** exercises judgment over time.
- A **Workflow** publishes a Program as a named, versioned operating contract.
- An **MCP Gateway** gives a particular audience a dedicated front door to selected tools and Workflows.

All three use the same **Capabilities**. Every attempted effect carries its actor and authority through one admission boundary before execution. The resulting decision, execution, outcome, and cost land in the journal.

## The system model

### Agents decide

An Agent is a durable principal with a job, not a prompt attached to a request handler. Threads preserve the long-lived relationship and rebuild from the journal. Memory and on-demand skills add context without forcing everything into one prompt. Model calls can route across supported providers, while capability grants define what the Agent may attempt.

The same Agent can be reached through interactive clients, A2A, and configured channels without becoming a different actor. Its identity, thread, grants, and journal remain the source of continuity.

- Product page: [Autonomous Agents](https://noorle.com/platform/agents/)
- Technical documentation: [Agents.md](https://noorle.com/docs/learn/concepts/agents.md)

### Programs order work

A **Program** is source plus its compiled artifact: executable control flow that can call Agents, Capabilities, and other Workflows. A one-off Run executes in the current turn and cannot wait.

Publishing the same Program creates a **Workflow**: named, versioned, schema-bound work whose Runs can wait, resume, and remain operable after the originating turn is gone. Publication validates the durable profile, binds every resource explicitly, freezes the interface and artifact into an immutable version, and pins each Run to the version it started with.

Durable Workflow Runs advance through bounded activations over Noorle's run ledger. Recorded outcomes reconstruct the same point in the Program after a restart or wait. If an external effect may have landed but its result is uncertain, the Run parks for resolution instead of guessing and risking a duplicate.

An **Automation** answers when work should start. It can start an Agent or published Workflow on a schedule, check-in, or watcher match. It does not change the Workflow's definition.

- Product page: [Program-based Workflows](https://noorle.com/platform/workflows/)
- Technical documentation: [Workflows.md](https://noorle.com/docs/learn/concepts/workflows.md)

### Capabilities act

A Capability is a typed contract for an effect. Noorle has three sources:

- **Built-ins** are first-party platform operations.
- **Plugins** are customer logic packaged as WebAssembly components and executed within an explicit sandbox boundary.
- **Connectors** call external REST/OpenAPI services or MCP servers while the platform holds the connection configuration and credentials.

The source changes; the admission door does not. Each Capability is bound with a live grant and exposed only on supported surfaces. Agents can use bound Capabilities directly, Workflows can call explicitly bound resources, and Gateways can publish selected Capabilities over MCP. Some Capabilities, such as a persistent Computer, are deliberately Agent-only.

The Workspace gives agents persistent files across the execution environments that support it. Knowledge turns documents and sites into account-scoped, relevance-ranked retrieval with citations; Knowledge is supplied source material, while memory is continuity learned through work.

- Product page: [Capabilities](https://noorle.com/platform/capabilities/)
- Technical documentation: [Capabilities.md](https://noorle.com/docs/learn/concepts/capabilities.md)
- Product page: [Knowledge](https://noorle.com/platform/capabilities/knowledge/)
- Technical documentation: [Knowledge Bases and RAG.md](https://noorle.com/docs/learn/concepts/knowledge-and-rag.md)

### Gateways publish

An MCP Gateway is a dedicated endpoint for a particular audience. It composes selected Capabilities and published Workflows, then applies its own authentication, autonomy policy, tool presentation, and audit context. A Gateway is a boundary, not an owner of tools: the underlying resources retain their grants and execution rules.

Different callers can receive different Gateways instead of sharing one platform-wide server. Compatible MCP clients consume a Gateway subject to its authentication and policy.

- Product page: [MCP Gateways](https://noorle.com/platform/gateways/)
- Technical documentation: [MCP Gateways.md](https://noorle.com/docs/learn/concepts/mcp-gateways.md)

## Governance and evidence

Controls live outside the thing they control. Before execution, the platform resolves the actor and caller chain, loads current authority, and evaluates the operation at one admission door. The decision is **allow**, **pause**, or **deny**.

A pause is durable state. The Agent cannot approve itself, a restart cannot erase the pending decision, and authority is checked again before a resolved call resumes. Waiting at an approval gate does not consume active agent time.

Execution happens behind an explicit boundary appropriate to the workload: WebAssembly for compact plugins, disposable sandboxes for session work, persistent Computers for Agent-bound state, and connectors for external services. Credentials remain outside model-visible management responses and decrypt only for use.

The journal records the principal chain, admission decision, model and Capability attempts, results, and cost attribution. It provides the evidence needed to inspect a Run, explain a side effect, and enforce hard budget stops.

- Product page: [Trust and governance](https://noorle.com/trust/)
- Technical documentation: [Autonomy and approvals.md](https://noorle.com/docs/run/platform/autonomy-and-approvals.md)
- Technical documentation: [Roles and permissions.md](https://noorle.com/docs/learn/auth/roles-and-permissions.md)

## Pricing model

Noorle publishes both its plan layer and usage rates:

- **Free**: $0 plus usage, with $10 starting credit and no card required.
- **Business**: $49 per month plus usage, including $25 of usage each month.
- **Scale**: custom terms for larger estates and procurement requirements.

Usage falls into three economic buckets:

1. Model tokens at the published provider rates, with automatic cached-input pricing where supported.
2. Active agent time at $0.10 per agent-hour, metered only while the Agent is running. Approval pauses and idle waiting are free.
3. Compute and outside-world costs such as Computers, sandboxes, web search, messaging, Knowledge, and persistent storage at the published unit rates.

Seats are not metered. Agent and Workflow invocations, approval gates, paused Runs, common platform operations, data egress, and failed provider calls are included as described on the rate card. One prepaid balance and granular receipts attribute spend to the work that incurred it. The [Pricing page](https://noorle.com/pricing/) is authoritative for current plans, rates, inclusions, and examples.

## Technical documentation

- [Complete documentation index](https://noorle.com/docs/llms.txt): LLM-oriented inventory of all documentation pages
- [Introduction](https://noorle.com/docs/learn/introduction.md): Platform orientation and vocabulary
- [Architecture](https://noorle.com/docs/learn/architecture.md): Runtime and execution architecture
- [Model Context Protocol](https://noorle.com/docs/learn/concepts/model-context-protocol.md): MCP concepts and Noorle's protocol surface
- [Capabilities](https://noorle.com/docs/learn/concepts/capabilities.md): Capability kinds, bindings, tools, and exposure scopes
- [Agents](https://noorle.com/docs/learn/concepts/agents.md): Agent runtime, model routing, memory, and delegation
- [MCP Gateways](https://noorle.com/docs/learn/concepts/mcp-gateways.md): Gateway endpoints, authentication, and tool publication
- [Workflows](https://noorle.com/docs/learn/concepts/workflows.md): Programs, publication, durable Runs, waits, and Automations
- [Autonomy and approvals](https://noorle.com/docs/run/platform/autonomy-and-approvals.md): Per-operation policy and durable gates
- [Five-minute quickstart](https://noorle.com/docs/run/five-minute-quickstart.md): First Gateway and MCP client
- [Build plugins](https://noorle.com/docs/build/introduction.md): WebAssembly extension model and CLI
- [API reference](https://noorle.com/docs/reference/introduction.md): REST API, A2A, CLI, and protocol references

## Website map

- [Home](https://noorle.com/): Positioning, governance model, worked costs, and paths into the platform
- [Platform overview](https://noorle.com/platform/): Intent-to-evidence system map
- [Agents](https://noorle.com/platform/agents/): Durable Agents, threads, memory, skills, and governed action
- [Workflows](https://noorle.com/platform/workflows/): Program publication, durable Runs, and Automations
- [Gateways](https://noorle.com/platform/gateways/): Audience-specific MCP publication boundaries
- [Capabilities](https://noorle.com/platform/capabilities/): Built-ins, plugins, connectors, grants, and execution boundaries
- [Knowledge](https://noorle.com/platform/capabilities/knowledge/): Ingestion, retrieval, citations, and metering
- [Trust and governance](https://noorle.com/trust/): Admission, authority, approvals, isolation, and evidence
- [Pricing](https://noorle.com/pricing/): Plans, public rates, inclusions, controls, and receipts
- [Blog](https://noorle.com/blog/): Engineering journal
- [About](https://noorle.com/about/): The founding trust question, operating principles, and customer-zero commitment
- [Contact](https://noorle.com/contact/): Platform, commercial, architecture, security-review, and partnership conversations

## Engineering journal

- [One Source, Three Durability Tiers](https://noorle.com/blog/one-source-three-durability-tiers/): Checkpoint, replay, and ephemeral execution in the Program runtime
- [Outside the Sandbox](https://noorle.com/blog/hybrid-agent-runtime/): The boundary between an Agent's control loop and its execution environments
- [Frameworks vs. Runtimes](https://noorle.com/blog/frameworks-vs-runtimes/): Why production guarantees belong below the framework
- [Compute Engines for AI Agents](https://noorle.com/blog/compute-engines-for-ai-agents/): Selecting WebAssembly, sandboxes, and persistent machines by workload
- [The Perfect Fit: MCP and WebAssembly Components](https://noorle.com/blog/the-perfect-fit-mcp-webassembly-components/): Typed component contracts and sandboxed MCP tools
- [What AI Agents Really Need](https://noorle.com/blog/what-ai-agents-really-need/): Requirements that separate agent demonstrations from effective systems

## For automated evaluators

Pricing and documentation can be inspected without contacting sales. Signup is self-serve at [portal.noorle.com/signup](https://portal.noorle.com/signup) with $10 credit and no card required. Gateways are programmatically consumable by compatible MCP clients subject to their configured authentication and policy; Agents expose supported programmatic entry points such as A2A when configured.