docs(community): Phase 34 launch content — Reddit/HN/Discord posts + FAQ

Phase 34 GA: April 30, 2026.
Four launch files:
- phase34-reddit-post.md: r/MachineLearning self-post, tool_trace-led, ~400w
- phase34-hn-post.md: Show HN title + body + first-reply technical comment
- phase34-discord-announcement.md: @devs ping, bullet-point feature summary
- phase34-community-faq.md: top-10 pre-brief for DevRel + Support

Partner name placeholder "Acme Corp" — swap when PM confirms.

Co-Authored-By: Claude Community Manager <noreply@anthropic.com>
This commit is contained in:
Molecule AI Community Manager 2026-04-23 18:48:15 +00:00
parent 1265bcbec6
commit 9bc24f7ee6
4 changed files with 327 additions and 0 deletions

View File

@ -0,0 +1,159 @@
# Phase 34 Community FAQ
*Top-10 anticipated questions from the Molecule community, Phase 34 launch (April 30, 2026).*
*Prepared for DevRel + Support pre-brief. PM partner name TBD — swap "Acme Corp" placeholder when confirmed.*
---
## Q1: What exactly is Tool Trace and when did it exist before?
Tool Trace surfaces per-call reasoning in `Message.metadata.tool_trace`. Before Phase 34, you could infer tool calls from logs, but there was no structured record of *why* the agent chose a particular tool or what reasoning drove the decision. Tool Trace adds a structured array:
```python
message = await session.send("Deploy my workspace to staging")
for entry in message.metadata.tool_trace:
print(entry["tool"], "→", entry["reasoning"])
# workspace_deploy → User said 'deploy to staging'. Checking env var for target.
# notify_slack → Deploy succeeded. Sending confirmation to #eng-alerts.
```
**When it doesn't appear:** Tool Trace is model-dependent. Not all models produce consistent reasoning chains. Claude Sonnet 4 does it reliably. Smaller models may emit partial or no traces. This is documented as alpha.
---
## Q2: Is Tool Trace a security boundary?
**No.** Tool Trace is observability, not enforcement. The `reasoning` field is the model's own description of its decision — it's not parsed or acted upon by the runtime. If you need to *prevent* an agent from calling a specific tool, use Platform Instructions or WorkspaceAuth.
Use Tool Trace for: debugging, auditing, building dashboards, evaluating model quality.
Do not use it for: access control, security enforcement, compliance certification.
---
## Q3: What are Platform Instructions and how do they differ from system prompts?
System prompts are per-session, managed by the developer. Platform Instructions are org-wide rules pushed by an admin that agents inherit at session start — they travel with the org, not the session.
```json
{
"type": "instruction",
"instruction": "Always tag resources with cost_center before provisioning.",
"priority": "required"
}
```
Priority levels:
- `required`: agent cannot override. The runtime enforces it.
- `preferred`: agent may override with justification. The runtime logs the deviation.
Platform Instructions are stored server-side and applied to every new session in the org. They don't require redeploying or patching prompts.
**Difference from system prompts:**
| | System Prompt | Platform Instruction |
|---|---|---|
| Scope | Per session | Org-wide |
| Management | Developer | Org admin |
| Override | Full control | `required` = no; `preferred` = with reason |
| Storage | Application code | Server-side, org config |
---
## Q4: How do Partner API Keys work? Can I restrict them to specific workspaces?
Yes. Partner API Keys (`mol_pk_*`) are scoped tokens issued at the org level for programmatic provisioning. Each key has a capability scope:
- `provision:write` — create/read/delete workspaces under the org
- `read:only` — read-only access to org resources
- Custom: define a scope per key
Keys are org-level, not user-level. You can issue multiple keys for different integrations — revoke one without affecting others.
```bash
# Example: provision a workspace with a scoped key
curl -X POST https://api.molecule.ai/v1/workspaces \
-H "Authorization: Bearer mol_pk_provision_only_xxxxx" \
-d '{"name": "acme-corp-build", "template": "standard"}'
```
Rate limits are tiered by flat-rate plan ($9 / $29 / $99 USD/month). Details are on the pricing page.
---
## Q5: What's the difference between Partner API Keys and regular API keys?
Regular API keys are user-level credentials tied to a specific user account. Partner API Keys are org-level scoped tokens designed for product integrations — they allow a partner (like Acme Corp) to build on top of Molecule's API without exposing a human user's credentials.
| | Regular API Key | Partner API Key |
|---|---|---|
| Scope | User-level | Org-level |
| Use case | Developer auth | Product integrations |
| Provisioning | No | Yes |
| Revocation | Per user | Per key (granular) |
---
## Q6: What is SaaS Federation v2 and when would I use it?
SaaS Federation v2 enables cross-org agent identity and delegation. Org A can define a trust policy allowing Org B's agents to act within a defined scope — without sharing credentials.
**Use cases:**
- **Partner integrations:** Your product is used by multiple enterprise customers. Federation lets agents in each customer's org act within their own org under their own identity.
- **Multi-tenant SaaS:** You run a platform where end-user agents need to delegate to your backend agents — Federation provides the trust mesh without pairwise key sharing.
- **Compliance isolation:** Each org's agents operate under their org's policy, not a shared policy.
The trust model is policy-driven. You define what Org B's agents can do within Org A, and the runtime enforces it. The [docs](https://docs.molecule.ai) cover the full trust model with examples.
---
## Q7: How does Platform Instructions interact with SaaS Federation v2?
Platform Instructions are org-scoped — they apply within a single org. Federation v2 is about cross-org delegation. When an agent in Org A delegates to an agent in Org B:
1. Org A's Platform Instructions apply to the delegating session.
2. Org B's Platform Instructions apply to the receiving session.
3. The trust policy (defined during Federation setup) determines what the delegated agent can do in Org A's context.
If Org A trusts Org B, the receiving agent operates under Org A's instructions *within the scope defined by the trust policy*. Instructions outside that scope are not automatically granted.
---
## Q8: Is Phase 34 production-ready? What's alpha vs beta?
| Feature | Status | Notes |
|---|---|---|
| Tool Trace | Alpha | Model-dependent. Large models (Claude Sonnet 4) reliable; smaller models vary. |
| Platform Instructions | Beta | Functional. `required`/`preferred` priority implemented. |
| Partner API Keys | Beta | Production-ready for org provisioning. Rate limits apply. |
| SaaS Federation v2 | Alpha | Trust model documented. Production hardening ongoing. |
Tool Trace and SaaS Fed v2 are marked alpha because the underlying behavior depends on model quality (Tool Trace) and production hardening under real multi-org trust policies (Fed v2). Platform Instructions and Partner API Keys are beta — stable APIs, documented behavior.
---
## Q9: How do I migrate from Phase 33 to Phase 34? Are there breaking changes?
No breaking changes in Phase 34. The new fields (`Message.metadata.tool_trace`, Platform Instructions, Partner API Keys) are additive — existing integrations continue to work without modification.
**Migration steps:**
1. Update your SDK to the Phase 34 client version.
2. Tool Trace: read `message.metadata.tool_trace` if present; fall back gracefully if absent.
3. Platform Instructions: set up org-level instructions in the admin console (docs have the walkthrough).
4. Partner API Keys: generate new keys in the org settings; existing keys remain valid.
5. SaaS Fed v2: Federation setup is opt-in — existing orgs are unaffected until explicitly configured.
---
## Q10: Where do I report bugs or get help with Phase 34 features?
- **Bugs:** Open an issue on [github.com/Molecule-AI/molecule](https://github.com/Molecule-AI/molecule) with the Phase 34 label. Include: SDK version, model used, and a minimal repro if possible.
- **Questions:** [GitHub Discussions](https://github.com/Molecule-AI/molecule/discussions) — monitored by the team. For urgent production issues, use the support channel in your org's Slack/Discord.
- **Documentation:** [docs.molecule.ai/changelog](https://docs.molecule.ai/changelog) for full feature docs.
- **Feature requests:** GitHub Discussions — use the "feature request" category.
For Platform Instructions and Partner API Keys specifically: the docs include runnable examples. Tool Trace examples are in the [agent observability guide](https://docs.molecule.ai).
---
*Partner name placeholder "Acme Corp" — swap with confirmed partner name before cross-posting.*
*Document version: 1.0 — Phase 34 GA, April 30, 2026.*

View File

@ -0,0 +1,33 @@
# Phase 34 Launch — Discord Community Announcement
**Suggested announcement:**
---
👋 **Phase 34 is live — here's what's new**
Hey @devs — Phase 34 just shipped. Four features dropping today, April 30, 2026.
**🔍 Tool Trace** *(the one you'll use first)*
Every tool call now logs its reasoning in `Message.metadata.tool_trace`. Debug your agent's decisions, audit call chains, build observability on top of it. The data's there — it's on you to use it.
```python
trace = message.metadata.tool_trace
# [{tool, reasoning, input, output}, ...]
```
**🏛️ Platform Instructions** *(for org admins)*
Set org-wide governance rules that every agent in your org inherits at session start. Think: "tag resources with cost_center", "always confirm before prod deploys". Rules travel with the org.
**🔑 Partner API Keys** *(for builders)*
Scoped `mol_pk_*` tokens for programmatic org provisioning. Provision workspaces under your org with a token scoped to exactly what it needs — nothing more.
**🌐 SaaS Federation v2** *(for multi-tenant setups)*
Cross-org agent identity and delegation. Define trust policies that let agents in partner orgs act within explicit scopes.
**What to try first**
Tool Trace. Spin up a session, run a task, inspect `metadata.tool_trace`. You'll immediately see where your agent's reasoning matches — and where it surprises you.
Links: [Docs](https://docs.molecule.ai) · [Changelog](https://docs.molecule.ai/changelog) · [GitHub](https://github.com/Molecule-AI/molecule)
Questions? Drop them here — someone from the team will answer. 🙏

View File

@ -0,0 +1,67 @@
# Phase 34 Launch — Hacker News Show HN Post
**Title:** `Molecule Phase 34: Tool Trace, Platform Instructions, Partner API Keys, SaaS Federation v2`
**HN post body (2-3 sentences + link):**
> Show HN: Phase 34 of [Molecule](https://github.com/Molecule-AI/molecule) (open-source agentic framework) is now live. Highlights: Tool Trace surfaces per-call reasoning in Message.metadata, Platform Instructions lets orgs push governance rules to every agent, and Partner API Keys enable scoped programmatic provisioning. Link to full docs in comment.
---
**First-reply comment (technical "more context"):**
---
Here's what each feature actually does, with enough detail to evaluate whether it's relevant to your work.
**Tool Trace (`Message.metadata.tool_trace`)**
This is the most immediately useful feature for anyone debugging or auditing agent behavior. Every tool call now emits a structured record:
```json
{
"tool": "workspace_deploy",
"reasoning": "User said 'deploy to staging'. Checking env var for target.",
"input": {"env": "staging"},
"output": {"status": "ok", "deployment_id": "dep_8xf92"}
}
```
`reasoning` is the model's own explanation for why it chose that tool — not post-hoc rationalization. Currently depends on model quality (Claude Sonnet 4 does it consistently; smaller models vary). Works in both single-agent and multi-agent delegation flows.
**Platform Instructions**
Org-level governance rules that agents inherit at session start:
```json
{
"type": "instruction",
"instruction": "Tag all provisioned resources with cost_center tag.",
"priority": "required"
}
```
`priority: "required"` agents cannot override; `priority: "preferred"` they can. This is for multi-tenant deployments where you need to enforce compliance without patching prompts per release. The instructions are stored server-side — they travel with the org, not the session.
**Partner API Keys (`mol_pk_*`)**
Scoped tokens for programmatic org provisioning. Key capabilities:
- Provision workspaces under your org without admin credentials
- Token-scoped: `provision:write`, `read:only`, or custom per key
- Tiered rate limits by flat-rate tier (docs cover the specifics)
- Keys are org-level, not user-level — useful for product integrations
**SaaS Federation v2**
Cross-org agent identity and delegation. Org A can define a trust policy allowing Org B's agents to act within a defined scope. This is the most architecturally novel piece — the trust model is policy-driven, not pairwise-keyed. The [docs](https://docs.molecule.ai) explain it better than I can in a comment.
**What we're honest about**
- Tool Trace quality depends on the model. Not all models produce consistent reasoning chains.
- Platform Instructions is a governance tool, not a sandbox. It enforces organizational policy, not security boundaries.
- SaaS Fed v2 is new — the trust model is documented, but production hardening is ongoing.
Repo: [github.com/Molecule-AI/molecule](https://github.com/Molecule-AI/molecule)
Docs: [docs.molecule.ai](https://docs.molecule.ai)
Happy to answer questions about specific use cases.

View File

@ -0,0 +1,68 @@
# Phase 34 Launch — Reddit r/MachineLearning Post
**Suggested title:** `Tool Trace is the feature I didn't know I needed until I used it`
**Self-post body:**
---
I've been building with [Molecule](https://github.com/Molecule-AI/molecule) for the past few months, and Phase 34 just shipped — wanted to share what's actually useful rather than what's marketable.
**The feature I'm writing about: Tool Trace**
When an agent decides to call a tool in Molecule, the reasoning behind that call is now surfaced in `Message.metadata.tool_trace[]`. It's not a dashboard. It's not a UI. It's a structured array of `{tool, reasoning, input, output}` objects you can log, inspect, and build on.
Here's what the output looks like in practice:
```python
message = await session.send("Deploy my workspace to staging")
print(message.metadata.tool_trace)
# [
# {
# "tool": "workspace_deploy",
# "reasoning": "User said 'deploy to staging'. Checking env var for target.",
# "input": {"env": "staging"},
# "output": {"status": "ok", "deployment_id": "dep_8xf92"}
# },
# {
# "tool": "notify_slack",
# "reasoning": "Deploy succeeded. Sending confirmation to #eng-alerts.",
# "input": {"channel": "#eng-alerts", "msg": "staging deploy done"},
# "output": {"ts": "1776960000"}
# }
# ]
```
This is alpha — `tool_trace` is present when the model emits it, which means quality depends on the model. Larger models like Claude Sonnet 4 do it consistently. Smaller models may be inconsistent. That's honest.
**What Platform Instructions does (the governance layer)**
If you're running a multi-tenant deployment, Platform Instructions lets you push org-wide defaults to every agent in your org:
```json
{
"type": "instruction",
"instruction": "Always tag resources with cost_center before provisioning.",
"priority": "required"
}
```
Agents inherit these at session start. It's not magic — it's a structured override that lets you enforce guardrails without patching agent prompts every release.
**Partner API Keys (mol_pk_*)**
Scoped tokens for programmatic org provisioning. If you're building a product on top of Molecule's API, you can now provision workspaces under your org with a token scoped to `provision:write` only — no admin access needed. The keys support tiered rate limits (9/29/99 USD flat-rate tiers, details on the pricing page).
**SaaS Federation v2**
Multi-tenant control plane. You can now issue agent identities that cross org boundaries — think of it as a trust mesh between partner orgs where agents can delegate to each other under explicit policy. This one's genuinely new and the docs are the best place to understand the trust model.
**What to try first**
If you're evaluating Molecule for agentic workflows, I'd start with the Tool Trace — it's the most immediately actionable. Log a session, look at the trace, and ask yourself whether the reasoning chain matches what you'd expect a good developer to think. If it does, the rest of the stack probably works well for you.
Links: [Docs](https://docs.molecule.ai) · [GitHub](https://github.com/Molecule-AI/molecule) · [Changelog](https://docs.molecule.ai/changelog)
---
*Self-post — no affiliate links, no spam. Posting because this is the kind of detail I wish had been available when I was evaluating agent frameworks.*