SignalFrame

Ship agents that hold their shape.

SignalFrame is an agent execution governance SDK. It turns plain-language behavioral intent into a Posture Profile made of weighted posture signals, then exports a ContextFrame that can travel with an agent handoff or runtime boundary.

SignalFrame helps AI builders make agent behavior explicit, inspectable, and portable.

v1 is the Posture Layer only: deterministic, testable, schema-backed, and ready for pilot validation.

Quick Start | How It Works | Posture Signals | Docs | Vision | Pilot Plan

---

At A Glance

SignalFrame gives you	Why it matters
Posture Profile	A structured description of how an agent should behave
Posture signals	Weighted, inspectable controls like clarity, warmth, reflection, and boundaries
ContextFrame	A portable governance snapshot for handoffs, debugging, and audit review
Deterministic parser	No hidden model calls, no stochastic interpretation, reproducible outputs
Stable JSON export	Shared schemas, golden fixtures, and SHA-256 integrity hashes

flowchart LR
  A[Behavioral intent] --> B[Posture Profile]
  B --> C[Weighted posture signals]
  C --> D[Policy hints]
  D --> E[ContextFrame]
  E --> F[Agent handoff or runtime boundary]

Loading

What Is SignalFrame?

Agent builders are moving from demos to real deployments. The question is shifting from:

Can the agent do the task?

to:

Can I trust how the agent behaves while doing the task?

Instead of burying behavioral intent in a prompt, you define it explicitly:

Make this agent direct, calm, bounded, low-risk, concise, and explicit when uncertain.

SignalFrame converts that intent into:

Artifact	Description
Posture Profile	Structured, versioned profile made of weighted posture signals
v1 default posture signals	Clarity, warmth, growth, reflection, agility, determination, boundaries
ContextFrame	Readable governance snapshot describing behavior, risk stance, tool hints, and rationale

The exported ContextFrame is meant to be injected into a downstream agent runtime or system message as the active behavioral contract.

Why This Matters

Prompt templates can describe behavior, but they do not make behavior easy to inspect, compare, hand off, or audit.

SignalFrame makes behavioral intent:

Quality	Meaning
Explicit	The intended posture is represented directly, not implied by prose alone
Inspectable	Builders can see which posture signals are active and why
Portable	ContextFrames can travel between sessions, tools, agents, and teams
Deterministic	The same intent and rule set produce the same output
Testable	Python and TypeScript implementations share fixtures and schemas

Agent builders need behavioral contracts, not just working demos. A ContextFrame is the first version of that contract.

---

Who This Is For Right Now

SignalFrame is an early-stage tool for builders exploring structured agent behavior and handoff governance.

It is a good fit for:

• AI consultants who hand agent workflows to clients or teammates.
• Product builders who want inspectable behavior controls without building a governance stack.
• Multi-agent developers who need distinct, stable roles across a workflow.
• Researchers, educators, and students studying deterministic AI governance patterns.

It is not yet a plug-and-play production safety solution. Teams adopting it today should expect to integrate the generated ContextFrame into their own runtime, prompt layer, test harness, or review process.

Why Not Just Use a Prompt?

Plain prompts are still useful. SignalFrame does not replace them.

SignalFrame helps when behavioral intent needs to become an artifact that can be inspected, compared, logged, tested, or handed off:

Prompt-only behavior	SignalFrame behavior
Intent is embedded in prose	Intent is represented as a Posture Profile
Behavioral changes are hard to compare	Posture signals can be compared directly
Handoff depends on reading the full prompt	ContextFrames carry posture, rationale, and policy hints
Revisions are informal	Outputs are deterministic and schema-backed
Trust is mostly subjective	Integrity hashes and fixtures support review

The plain-language intent is still human-authored. The difference is that SignalFrame converts it into a structured, portable governance snapshot instead of leaving it only as prompt text.

---

What v1 Does

Capability	Status
Deterministic rule-based intent parsing	Included
Posture signal validation from 0.0 to 1.0	Included
Posture Profile creation	Included
ContextFrame generation	Included
Response and tool policy hints	Included
Stable JSON export with SHA-256 integrity	Included
Python SDK	Included
TypeScript SDK	Included
Shared schemas and golden fixtures	Included
Pilot validation materials	Included

What v1 Does Not Do

Not in v1	Notes
Web UI or database	SDK and schema layer only
LLM API calls	Parsing is deterministic and local
Agent orchestration	SignalFrame produces governance artifacts, not agent graphs
Enterprise dashboard	Future layer, after pilot evidence
Memory, personalization, or context routing	Future governance layers
Personality sliders	SignalFrame is posture governance, not a personality framework

---

Quick Start

Install

Python

uv pip install -e '.[dev]'

TypeScript / Node

npm install
npm run build

Python

from signalframe import ContextFrame, parse_intent_to_profile

profile = parse_intent_to_profile(
    "Be direct, calm, and low-risk.",
    name="Governed assistant",
)

frame = ContextFrame.from_profile(profile)

print(frame.signals.to_dict())
print(frame.response_policy_hints)
print(frame.export_json())

TypeScript

import { ContextFrame, parseIntentToProfile } from "./packages/typescript/src/index.js";

const profile = parseIntentToProfile("Be direct, calm, and low-risk.", {
  name: "Governed assistant",
});

const frame = ContextFrame.fromProfile(profile);

console.log(frame.signals.toDict());
console.log(frame.responsePolicyHints);
console.log(frame.exportJson());

Example Output Shape

{
  "version": "contextframe/v1",
  "profile": {
    "id": "profile_...",
    "name": "Governed assistant"
  },
  "source_intent": "Be direct, calm, and low-risk.",
  "signals": {
    "clarity": 0.7,
    "warmth": 0.62,
    "growth": 0.5,
    "reflection": 0.67,
    "agility": 0.5,
    "determination": 0.63,
    "boundaries": 0.75
  },
  "response_policy_hints": ["Use concise, structured responses with clear next steps."],
  "tool_policy_hints": ["Prefer reversible actions and require explicit confirmation for high-impact operations."]
}

---

Posture Signals

SignalFrame v1 ships with a default set of posture signals. The count is intentionally treated as versioned product behavior, not permanent brand language.

Signal	Reads as	Governance role
clarity	Direct and unambiguous	Helps responses and tool outcomes stay traceable
warmth	Empathetic and collaborative	Supports trust and handoff quality
growth	Open to learning and adaptation	Encourages improvement over repeated work
reflection	Cautious about consequences	Improves risk awareness
agility	Quick to adapt	Helps the agent respond to local context
determination	Persistent toward goals	Supports completion in long workflows
boundaries	Strict about scope and risk	Supports safety, reversibility, and compliance

How It Works

1. Parse Intent

SignalFrame normalizes plain-language behavioral intent and runs it through a deterministic rule set. No model inference is used.

2. Map to Posture Signals

Matched terms adjust one or more posture signals by predefined deltas in the 0.0 to 1.0 range. Each signal is clamped to keep the profile bounded and comparable.

3. Generate Policy Hints

Signal values produce deterministic response and tool-policy hints, such as being explicit about uncertainty or requiring confirmation for high-impact operations.

4. Export a ContextFrame

The ContextFrame records the active behavioral contract:

ContextFrame includes	Purpose
Source intent	Preserves the user's original behavioral instruction
Signals	Makes the interpreted posture inspectable
Response policy hints	Guides tone, structure, caution, and challenge
Tool policy hints	Guides tool selection, confirmation, and traceability
Rationale	Explains why the posture was interpreted that way
Integrity hash	Detects accidental or unauthorized changes

---

Try These First

Try	What to inspect
Parse "warm but bounded"	See how warmth and boundaries move
Export a ContextFrame	Review JSON structure and integrity hash
Compare two profiles	Contrast "risk-seeking researcher" with "cautious advisor"
Modify exported JSON	Re-run integrity checks to detect tampering
Reuse a profile	Confirm deterministic reproduction across sessions

Development

Run Tests

Python

.venv/bin/python -m pytest

TypeScript

npm test
npm run build

Project Structure

packages/
  python/
    src/signalframe/          # Core Python SDK
    tests/
  typescript/
    src/                      # Core TypeScript SDK
    tests/
shared/
  schema/                     # JSON schemas
  fixtures/                   # Golden postures
docs/
  pilot-validation-plan.md    # Pilot test design
  known-limitations.md
  quick-start.md

---

Documentation

Topic	Link
Vision and strategy	VISION.md
Mathematical appendix	SignalFrame-math.md
Vision math section draft	VISION-math-section.md
Quick start guide	docs/quick-start.md
Pilot validation plan	docs/pilot-validation-plan.md
Known limitations	docs/known-limitations.md
Schemas	shared/schema/
Golden fixtures	shared/fixtures/golden-postures.json

Status

Area	Current state
Phase	Pilot Validation Ready
Python SDK	Implemented
TypeScript SDK	Implemented
Shared schemas and fixtures	Implemented
Pilot materials	Included
Local Python tests	13 passing
Local TypeScript tests	13 passing
TypeScript build	Passing

SignalFrame is release-ready for pilot validation, not yet market-validated.

Community And Support

Channel	Link
Discord	discord.gg/signalframe
GitHub Issues	888noonie/SignalFrame/issues
Pilot Sign-Up	docs/pilot-validation-plan.md

License

LICENSE

About

SignalFrame is an open SDK for posture governance in AI agent workflows. Read more in VISION.md.