Bootstrap the Agentic Runtime research/ideation process

.github/CODEOWNERS

@@ -0,0 +1,3 @@
+# Review for this repo routes to the Agentic Runtime working-group leads.
+# See: https://github.com/cloudfoundry/community/blob/main/toc/working-groups/agentic-runtime.md
+*       @beyhan @wayneeseguin @rkoster @itsouvalas

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,15 @@
+<!-- Thanks for contributing a research note! Please confirm the checklist below. -->
+
+## What is this note about?
+
+<!-- One or two sentences. -->
+
+## Checklist
+
+- [ ] My note lives in `research/` and uses a lowercase kebab-case filename.
+- [ ] It starts from `research/TEMPLATE.md` and has valid frontmatter
+      (`title`, `author`, `date`, `tags`, `status`, `sources`).
+- [ ] It has the four sections: Summary, Key findings, CF relevance, Open questions.
+- [ ] I added relevant `tags` (see the suggested vocabulary in `IDEATION.md`).
+- [ ] Sources are linked.
+- [ ] It's on-topic for agentic workloads on Cloud Foundry 

.github/scripts/validate_notes.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""Validate research notes in research/.
+
+For every research/*.md file except README.md and TEMPLATE.md this checks:
+  - the filename is lowercase kebab-case ending in .md
+  - a YAML frontmatter block is present and parses
+  - required frontmatter keys are present and well-typed
+  - the four required body section headings are present
+
+Exits non-zero (printing every problem) if any note is invalid.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import pathlib
+import re
+import sys
+
+import yaml
+
+RESEARCH_DIR = pathlib.Path("research")
+SKIP = {"README.md", "TEMPLATE.md"}
+
+REQUIRED_KEYS = {
+    "title": str,
+    "author": str,
+    "date": object,  # validated separately
+    "tags": list,
+    "status": str,
+    "sources": list,
+}
+ALLOWED_STATUS = {"draft", "reviewed"}
+REQUIRED_SECTIONS = [
+    "## Summary",
+    "## Key findings",
+    "## CF relevance",
+    "## Open questions",
+]
+FILENAME_RE = re.compile(r"^[a-z0-9]+(-[a-z0-9]+)*\.md$")
+FRONTMATTER_RE = re.compile(r"^---\n(.*?)\n---\n", re.DOTALL)
+DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
+
+
+def validate_file(path: pathlib.Path) -> list[str]:
+    problems: list[str] = []
+    name = path.name
+
+    if not FILENAME_RE.match(name):
+        problems.append(
+            f"filename must be lowercase kebab-case ending in .md (got '{name}')"
+        )
+
+    text = path.read_text(encoding="utf-8")
+
+    match = FRONTMATTER_RE.match(text)
+    if not match:
+        problems.append("missing YAML frontmatter block (must start with '---' on line 1)")
+        return [f"{path}: {p}" for p in problems]
+
+    try:
+        meta = yaml.safe_load(match.group(1))
+    except yaml.YAMLError as exc:
+        problems.append(f"frontmatter is not valid YAML: {exc}")
+        return [f"{path}: {p}" for p in problems]
+
+    if not isinstance(meta, dict):
+        problems.append("frontmatter must be a YAML mapping")
+        return [f"{path}: {p}" for p in problems]
+
+    for key, expected_type in REQUIRED_KEYS.items():
+        value = meta.get(key)
+        if value in (None, "", [], {}):
+            problems.append(f"missing required frontmatter key '{key}'")
+            continue
+        if expected_type is not object and not isinstance(value, expected_type):
+            problems.append(f"frontmatter key '{key}' must be a {expected_type.__name__}")
+
+    status = meta.get("status")
+    if isinstance(status, str) and status not in ALLOWED_STATUS:
+        problems.append(
+            f"'status' must be one of {sorted(ALLOWED_STATUS)} (got '{status}')"
+        )
+
+    date_val = meta.get("date")
+    if date_val not in (None, "", [], {}):
+        if isinstance(date_val, dt.date):
+            pass  # YAML already parsed a date
+        elif isinstance(date_val, str) and DATE_RE.match(date_val):
+            pass
+        else:
+            problems.append("'date' must be in YYYY-MM-DD format")
+
+    body = text[match.end():]
+    for section in REQUIRED_SECTIONS:
+        if not re.search(rf"^{re.escape(section)}\s*$", body, re.MULTILINE):
+            problems.append(f"missing required section heading '{section}'")
+
+    return [f"{path}: {p}" for p in problems]
+
+
+def main() -> int:
+    if not RESEARCH_DIR.is_dir():
+        print(f"error: '{RESEARCH_DIR}/' directory not found", file=sys.stderr)
+        return 1
+
+    notes = sorted(p for p in RESEARCH_DIR.glob("*.md") if p.name not in SKIP)
+
+    problems: list[str] = []
+    for note in notes:
+        problems.extend(validate_file(note))
+
+    if problems:
+        print("Research note validation failed:\n")
+        for problem in problems:
+            print(f"  - {problem}")
+        print(f"\n{len(problems)} problem(s) across {len(notes)} note(s).")
+        return 1
+
+    print(f"OK: {len(notes)} research note(s) valid.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.github/workflows/lint.yml

@@ -0,0 +1,32 @@
+name: Validate research notes
+
+on:
+  pull_request:
+    paths:
+      - "research/**"
+      - ".github/scripts/validate_notes.py"
+      - ".github/workflows/lint.yml"
+  push:
+    branches: [main]
+    paths:
+      - "research/**"
+      - ".github/scripts/validate_notes.py"
+      - ".github/workflows/lint.yml"
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: pip install "pyyaml>=6"
+
+      - name: Validate research notes
+        run: python .github/scripts/validate_notes.py

CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Code of Conduct
+
+The Cloud Foundry Agentic Runtime Working Group, like all Cloud Foundry community spaces,
+operates under the **Cloud Foundry Foundation Code of Conduct**.
+
+Please read it here: https://www.cloudfoundry.org/code-of-conduct/
+
+By participating in this repository — through issues, pull requests, reviews, or any other
+interaction — you agree to abide by its terms.
+
+To report a concern, follow the reporting instructions in the linked Code of Conduct, or
+reach a working-group lead in [#ai-wg](https://cloudfoundry.slack.com/archives/C0B214KJ1HA)
+on the Cloud Foundry Slack.

CONTRIBUTING.md

@@ -0,0 +1,63 @@
+# Contributing
+
+Thanks for helping shape the future of agentic workloads on Cloud Foundry. During the
+current **research phase**, contributions take the form of **research notes** added to
+[`research/`](./research) via pull requests.
+
+For the why and the bigger picture, read [`IDEATION.md`](./IDEATION.md).
+
+## Quick start
+
+1. **Fork** this repository (or, if you're a working-group member with write access, create
+   a branch).
+2. **Copy the template:**
+   ```bash
+   cp research/TEMPLATE.md research/my-topic.md
+   ```
+3. **Fill it in.** Keep it short, sourced, and outward-looking (see
+   [`IDEATION.md`](./IDEATION.md) for what Phase 1 is after). See
+   [`research/README.md`](./research/README.md) for the frontmatter schema.
+4. **Commit your note:**
+   ```bash
+   git add research/my-topic.md
+   git commit -m "Add research note: my topic"
+   ```
+5. **Open a pull request.** A CI check validates your note's frontmatter and structure. A
+   working-group tech lead will give it a quick look and merge.
+
+## Filename convention
+
+- Lowercase **kebab-case**, ending in `.md`: `research/agent-frameworks.md`.
+- If your topic collides with an existing note, add your GitHub handle as a suffix:
+  `research/agent-frameworks-rkoster.md`.
+
+## Frontmatter
+
+Every note starts with a YAML frontmatter block. Required keys: `title`, `author`, `date`,
+`tags`, `status`, `sources`. The `cf_areas` key is optional. The full schema and field
+descriptions live in [`research/README.md`](./research/README.md).
+
+Tagging well matters — tags are how the workshop clusters notes into themes. See the
+suggested (non-binding) vocabulary in
+[`IDEATION.md`](./IDEATION.md#tagging-how-themes-will-emerge).
+
+## Review & merge
+
+Research notes are low-risk, so we optimize for throughput:
+
+- CI validates frontmatter, filename, and required sections.
+- Any working-group **tech lead** can merge once CI passes and the note is on-topic and not
+  a duplicate.
+- Substantive review of *ideas* happens at the workshop, not as a merge gate.
+
+## Contributor License Agreement (CLA)
+
+All committers to a Cloud Foundry Foundation project must sign a Contributor License
+Agreement. You don't need to do anything up front: the **EasyCLA** bot comments on your
+first pull request with a link to sign (individual or corporate). Once it's signed, the
+CLA check goes green and your PR can be merged. You can also
+[sign in to EasyCLA](https://corporate.v1.easycla.lfx.linuxfoundation.org/) ahead of time.
+
+## Code of conduct
+
+This project follows the [Cloud Foundry Code of Conduct](./CODE_OF_CONDUCT.md).

IDEATION.md

@@ -0,0 +1,111 @@
+# Ideation Brief — Agentic Runtime Research Phase
+
+**Status:** Proposed (this brief is itself under review — feedback welcome on the PR).
+**Working group:** [Cloud Foundry Agentic Runtime](https://github.com/cloudfoundry/community/blob/main/toc/working-groups/agentic-runtime.md)
+
+## Why this phase exists
+
+The Agentic Runtime Working Group is new, and the design space — running AI agents and
+LLM-powered workloads as first-class citizens on Cloud Foundry — is broad and moving fast.
+Before committing to specific designs or RFCs, we want to map the landscape together:
+gather what the community already knows and surface prior art from the wider ecosystem.
+With that map in hand, the workshop can then see where Cloud Foundry's primitives help or
+fall short.
+
+This repository is the home for that research. It is deliberately **lightweight and
+open**: the goal is breadth of input from anyone interested, not polished deliverables.
+
+## The four-phase roadmap
+
+This research phase is step one of four:
+
+1. **Research (now, ~a few weeks).** Contributors submit short, sourced **research notes**
+   into [`research/`](./research) via pull requests. We want broad, *outward-looking*
+   coverage of the wider agentic ecosystem — relevant technologies, prior art, and how
+   others solve these problems. Where Cloud Foundry fits comes later.
+2. **Workshop.** The working group meets to read across the accumulated notes and cluster
+   them into **themes**. Themes are *not* defined up front — they emerge from what people
+   actually contribute.
+3. **Match.** Working-group members align their interests with the identified themes and
+   form small groups around them.
+4. **POC / RFC.** Each theme group spins up focused work — proofs-of-concept and Cloud
+   Foundry RFCs — feeding the platform roadmap.
+
+We are building only what Phase 1 needs right now. Structure for themes, POCs, and RFCs
+will be added once the workshop has shaped it.
+
+## What to contribute in Phase 1
+
+**Look outward.** Phase 1 is about understanding the wider agentic and AI ecosystem — not
+about cataloguing Cloud Foundry. Where Cloud Foundry's primitives help or fall short is
+something we want to *discover* at the workshop, drawn from this research, rather than
+assume up front.
+
+**In scope** — research notes that inform the design space, such as:
+
+- Analyses of agent frameworks, protocols, and platforms (how others solve a problem).
+- Prior art and standards — identity, sandboxing, observability, orchestration conventions.
+- How adjacent runtimes and platforms (Kubernetes, serverless, other PaaS) handle agentic
+  workloads.
+- Surveys of the surrounding ecosystem and where it's heading.
+
+**Out of scope for now:**
+
+- Finished solutions, designs, or RFCs — those come in Phase 4, after the workshop. A note
+  may *raise* questions and point at possible directions, but its job is to inform, not to
+  settle on a final answer.
+- Definitive Cloud Foundry gap lists. Identifying gaps is an **outcome** of this phase,
+  synthesized at the workshop from the body of research — not a starting point any one
+  contributor supplies.
+
+## What makes a good research note
+
+- **Sourced.** Link to the primary material so others can dig in.
+- **Summarized.** A few sentences capturing the essence — assume the reader is busy.
+- **Outward-looking, with a light CF lens.** The substance is the external research; add a
+  short note on why it might matter for Cloud Foundry. A loose or speculative connection is
+  fine — "not sure how this maps yet" is a perfectly good answer.
+- **Honest about open questions.** Unknowns are valuable signal for the workshop.
+
+Each note follows a small template — see [`research/TEMPLATE.md`](./research/TEMPLATE.md).
+[`CONTRIBUTING.md`](./CONTRIBUTING.md) explains the mechanics.
+
+## Tagging: how themes will emerge
+
+Each note carries free-form `tags` in its frontmatter. At the workshop we'll use these
+tags to cluster notes into themes — so tagging well is how you influence the agenda.
+
+Tags are **descriptive, not prescriptive.** To reduce noise, here is a *non-binding*
+starting vocabulary drawn from the working-group charter. Use these where they fit, and
+invent new ones where they don't:
+
+- `identity` — workload/agent identity, authn, authz
+- `runtime-lifecycle` — how agents are deployed, started, stopped, resumed
+- `sandboxing-isolation` — execution isolation, policy enforcement
+- `orchestration` — multi-step / multi-agent coordination
+- `inter-agent-comms` — agent-to-agent and agent-to-tool protocols
+- `observability-governance` — telemetry, audit, compliance
+- `autoscaling` — event-driven and scale-to-zero patterns
+- `ecosystem-survey` — landscape scans of tools, frameworks, vendors
+
+**These are hints, not buckets.** Don't file your note into a predetermined theme — just
+describe it accurately and let the themes emerge.
+
+## Timeline
+
+Specific dates (the research window length and the workshop date) are set at the
+working-group kickoff and announced in
+[#ai-wg](https://cloudfoundry.slack.com/archives/C0B214KJ1HA) on Slack. Expect the research
+window to run a few weeks.
+
+## How to participate
+
+1. Read [`CONTRIBUTING.md`](./CONTRIBUTING.md).
+2. Add a note using the template and open a PR.
+3. Join the conversation in [#ai-wg](https://cloudfoundry.slack.com/archives/C0B214KJ1HA).
+
+## Feedback on this process
+
+This brief is part of the first pull request *on purpose* — so the working group can shape
+the process before research arrives at volume. If something here doesn't serve the goal,
+say so on the PR.