update Modus and Apps overview

apps/overview.mdx

@@ -0,0 +1,85 @@
+---
+title: Apps
+description:
+mode: "wide"
+sidebarTitle: "Overview"
+"og:title": "Overview - Apps"
+---
+
+Apps in Hypermode are how you package and deploy agents and AI-native apps.
+
+An App is a collection of related agents, tools, and memory, working together to
+perform a cohesive set of tasks towards an outcome. Whether you're coordinating
+a team of agents or creating multi-step agentic flows, Apps are the top-level
+construct that unifies your AI system.
+
+## Why Apps?
+
+Building an agent is powerful. But real-world use cases rarely stop at one. As
+your AI system grows, you'll often need to:
+
+- **Coordinate multiple agents** with different roles
+- **Share tools and context** across flows
+- **Persist memory** and long-term learning for a domain
+- **Deploy and version** your system as a single unit
+
+That's where Apps come in. Apps give structure to your agentic architecture.
+They let you group related components - agents, tools, memories, and APIs- into
+one deployable unit.
+
+## What's in an App?
+
+Apps in Hypermode are modular and flexible, designed to let you build complex
+systems by assembling reusable components.
+
+Every App on Hypermode is made up of the following components:
+
+### Agents
+
+Agents are the workers that reason, plan, and act. Apps can include one or many
+agents, each with their own role. You can assign different models, tools, and
+memory configurations to each agent, or allow them to collaborate via shared
+context.
+
+### Tools
+
+Tools are how agents take action. These include custom functions, external APIs,
+or built-in Hypermode tools (like data fetching or search). Apps define which
+tools are available to which agents and can scope tools to specific tasks or
+agent roles.
+
+### Memory
+
+Apps can define long-term and short-term memory for agents using Hypermode's
+memory primitives. This allows your agents to remember past interactions, user
+preferences, task outcomes, and more to enable persistent, contextual behavior
+over time.
+
+### Connections
+
+Apps can include third-party integrations like GitHub, Slack, or internal APIs
+via the Model Context Protocol (MCP). These integrations allow agents to
+interact with external systems in a structured, secure way.
+
+### Decision interface
+
+Apps use a decision interface to let you work asynchronously with agents. This
+is useful for long-running tasks, approvals, or cases where agent actions need
+to be reviewed before execution.
+
+### Runtime
+
+Each App includes metadata for tracking versions, environments, and ownership.
+You can define environment variables, set up deployment environment (staging vs
+production), and manage runtime settings that affect how agents are executed.
+
+## Agent development lifecycle
+
+Apps support the full development lifecycle:
+
+- **Develop locally** using the [Hyp CLI](/hyp-cli) or in a **conversational
+  interface** using Threads
+- **Test and debug** agent behavior
+- **Deploy to production** with versioning and rollback support
+- **Monitor and trace** interactions using built-in observability
+- **Collaborate and share** across teams with access controls and roles

docs.json

@@ -62,6 +62,10 @@
               "graphs/manage-graph"
             ]
           },
+          {
+            "group": "Apps",
+            "pages": ["apps/overview"]
+          },
           {
             "group": "Tools",
             "pages": ["model-router", "hyp-cli"]

modus/overview.mdx

@@ -8,50 +8,72 @@ sidebarTitle: "Overview"
 
 ## What is Modus? {/* vale Google.Contractions = NO */}
 
-Modus is an open source, serverless framework for building functions and APIs,
-powered by WebAssembly.
+Modus is an open source agent framework (including both a runtime and SDK) built
+on WebAssembly. It is designed for rapid iteration and production-ready
+performance for agents and AI APIs. With Modus, you have all the components you
+need to go from zero to a fully functioning agent.
 
-You write your app logic in Go or AssemblyScript, and Modus provides additional
-features to easily integrate models, data, and external services.
+{/* // TODO: [Image] // TODO: [Link to v1 vision blog] */}
 
-To **build apps that are thoughtful, fun, and effective**, we often need to
-integrate models in different forms, whether generative large language models or
-classical machine/deep learning models.
+## Key features
 
-Your app might be a simple create, read, update, and delete (CRUD) function that
-has a single model to identify similar entries. Or, it could be a complex
-agentic reasoning system that chains dozens of models and data sources together.
-**Modus creates a way of working with models that scales with your needs.**
+Modus is built from the ground up for agent development.
 
-Modus exists to make it easier for you to build the apps of your dreams.
+| Feature                     | Description                                                                                      |
+| --------------------------- | ------------------------------------------------------------------------------------------------ |
+| WebAssembly powered runtime | A small, portable, and highly efficient execution engine for deploying agents anywhere           |
+| Flexible tool support       | Consume Model Context Protocol (MCP) servers or build your own custom tools to power your agents |
+| Triggered agent actions     | Define and trigger specific actions for your agents to perform                                   |
+| Built-in agent memory       | Support for both short-term and long-term agent memory, powered by knowledge graphs              |
+| Agent operations            | Built-in inference logging and traces for agent-level observability                              |
+| Serverless scale-to-zero    | Each agent spins up on demand and scales to zero in idle state                                   |
+| Fully open source           | No vendor lock-in, but designed for low cold-start times and rapid scaling                       |
 
 <Note>
   Modus is a multi-language framework. It currently includes support for Go and
   AssemblyScript, a WebAssembly compatible TypeScript-like language. Additional
   language support is in development.
 </Note>
 
-## What is Modus good for? {/* vale Google.Contractions = NO */}
+## When to use Modus
 
-We designed Modus primarily as a general-purpose app framework, it just happens
-to treat models as a first-class component. With Modus you can use models, as
-appropriate, without additional complexity.
+### Rapid prototyping to scaling with confidence
 
-However, Modus is best for apps that require sub-second response times. We've
-made trade-offs to optimize for speed and simplicity.
+Start with one-line agent definitions using **AgentKit** - no infrastructure
+setup, no complex wiring. You get streaming UI, context management, and logging
+out of the box. Once your agent logic is solid, deploy via the same framework.
+Because agents are WebAssembly based and serverless, they incur zero cost when
+idle and start fast under load.
 
-For more inspiration, check out the
-[Modus recipes](https://github.com/hypermodeinc/modus-recipes).
+### Language-agnostic logic, safely
+
+With WebAssembly's secure isolation environment, define agent behavior in Go or
+AssemblyScript. Compile to WebAssembly and Modus runs it securely. Each agent
+runs as a lightweight actor: self-contained, message-driven, and supervised by
+the runtime.
+
+### Persistent context beyond sessions
+
+For use-cases like multi-day workflows, personal assistants, tutoring, or
+domain-specific agents (for example ticketing systems), long-term context is
+crucial. Modus provides it without requiring a dedicated database layer. Modus'
+built-in short-term memory handles conversational state and context within
+agents. Connect to long-term graph memory for externalized and persisted, but
+serverless-friendly memory. You gain full "recall" - across sessions and
+workflows- without maintaining stateful servers.
 
-## Main features
+### Observability at the functional level
 
-A few of the core Modus features include:
+When you need clarity on _why_ the agent did something, no just _what_ the model
+saw, Modus gives you full introspection. Agent-level tracing gives you a
+complete timeline of agent behavior. Inference logging allows you to visualize
+latency and data flow, audit decisions, or replay session history for debugging.
 
-| Feature                                     | Description                                                                                  |
-| ------------------------------------------- | -------------------------------------------------------------------------------------------- |
-| [Multi-Language](/modus/project-structure)  | Write functions in Go and AssemblyScript, with additional language support in development    |
-| [Auto-Generated API](/modus/api-generation) | A secure API is automatically generated from your function signatures                        |
-| [Model Integration](/modus/model-invoking)  | Connect and invoke AI models from different providers, without learning a new SDK            |
-| [Search](/modus/search)                     | Add natural language search and recommendations with integrated vector embeddings            |
-| [Authentication](/modus/authentication)     | Secure your API endpoints with minimal configuration                                         |
-| **WebAssembly Runtime**                     | Small and portable execution engine for deployment across server, edge, and desktop computes |
+### Serverless efficiency, no vendor lock-in
+
+Agents activate only when needed. No uptime cost when idle. Use Modus anywhere -
+in the cloud or on-prem - without vendor lock-in or proprietary constraints.
+Optimize costs without sacrificing flexibility or control over infrastructure.
+
+For more inspiration, check out the
+[Modus recipes](https://github.com/hypermodeinc/modus-recipes).

styles/config/vocabularies/general/accept.txt

@@ -1,5 +1,6 @@
 [Aa]gentic
 [Aa]lterSchema
+[Aa]pp
 [Bb]oolean
 [Cc]ollections
 [Cc]omputeDistance