Product Strategy
What you'll learn
- Why Craik is a durable agent runtime, not another framework.
- The agent-runner strategy (Codex / Claude / Gemini as first-class).
- The license rationale and the brand boundary.
- The patterns Craik borrows from local-agent and multi-agent runtimes, plus the things Craik adds on top.
A new product category
The opportunity is to combine approachable local-agent ergonomics, multi-agent decomposition, and Stigmem's durable memory/truth substrate into a new product category: a durable runtime for agent organizations.
Craik should build on strong agent-runtime and multi-agent coordination patterns without becoming a clone of any adjacent tool.
Agent runner strategy
Craik should be built for agents to use directly. The initial first-class runner targets are Codex, Claude, and Gemini — direct adapters that consume the same Craik contracts.
Craik core stays runner-agnostic through contracts, and the first implementation ships direct runner adapters that can:
Receive case files
Project case file, policy envelope, and capability grants — typed inputs the adapter normalizes for the runner.
Execute or guide
Run a fixture-backed task or hand off to a live runner with the same contracts on the way back.
Emit typed worker results
Findings, artifacts, assumptions, risks, contradictions — preserved
as craik.worker_result.
Emit receipts & handoffs
Capability receipts and durable handoffs at the same boundary every other governed action uses.
Propose memory updates
Run outputs may create reviewable memory proposals — but never write durable facts directly.
Craik should not depend on another agent framework as its initial execution layer. Adjacent tools are useful references for local and self-hosted ergonomics, gateway design, workspace identity, sessions, tool descriptors, skills, and channel integrations. Craik's first agent path is direct integration with Codex, Claude, and Gemini.
License strategy
Craik uses the MIT License.
The code license stays separate from brand and trademark usage. Eidetic Labs reserves the right to define how the Craik name, marks, and hosted service branding may be used.
The license choice supports:
Low-friction adoption
Individuals, startups, and enterprises can integrate Craik without license-review friction.
Permissive norm
Matches the permissive license norm set by comparable agent projects.
Plugin & adapter growth
Makes downstream packages easier to ship under their own choice of license.
Commercial flexibility
Leaves room for hosted services and enterprise offerings without changing the runtime license.
Broader distribution
Permissive licensing helps the runtime concepts travel further as reference patterns.
Local agent runtime patterns
The strongest local-agent runtime lessons are operational and ergonomic.
Craik adopts
- Self-hosted first — run locally or on your own infra.
- Gateway ergonomics — one entry point for users, agents, tools, sessions, channels.
- Workspace identity — scoped files, runtime config, persistent session artifacts.
- Session continuity — agent runs survive restarts and stay inspectable.
- Skills as operating guidance — installable, scoped, reusable.
- Typed tool descriptors — tools as explicit capabilities, not hidden prompt affordances.
- Channel flexibility — CLI first, UI/API next, chat surfaces later.
Craik adds
- Structured case files instead of broad transcript state.
- Capability receipts for important tool use.
- Explicit memory-write policy — proposal-first by default.
- Trust-aware facts with scope and provenance.
- Contradiction workflows instead of silent overwrites.
- Project-level work graphs connecting tasks, evidence, and decisions.
Adjacent local runtimes are design references and possible later integration targets, not core dependencies.
Multi-agent coordination patterns
The strongest multi-agent lessons are about decomposition, role separation, and durable coordination.
Craik adopts
- Orchestrator plus specialists for complex work.
- Isolated worker context — task-relevant only.
- Typed result objects — validated, routable.
- Parallel execution where safe.
- Task boards that outlive a single chat session.
- Worker heartbeats and blocks for progress, blocking, and context requests.
- Role profiles with explicit responsibilities, tools, and policy.
Craik adds
- Handoffs, not summaries — workers write durable continuity records.
- Work graph linkage — task boards connect to typed cross-cutting state.
- Evidence-bearing outputs — specialist results become artifacts, not chat.
- Tracked contradictions instead of unresolved disagreement.
- Stigmem-backed memory instead of orchestrator-only memory.
What Craik adds
Craik's novel surface is built around features that are difficult to retrofit into prompt-first systems.
Project case file
The task-specific context package assembled before an agent acts — objective, policy envelope, facts, ADRs, repository and GitHub state, recent handoffs, stale-risk warnings, contradiction warnings, and required verification.
Durable handoff
Machine-readable continuity record — what was done, what changed, evidence used, commands and tests run, facts learned and invalidated, unresolved questions, blocked items, risks, and recommended next steps.
Capability receipt
Concise record of important runtime action — file writes, shell, GitHub writes, memory writes, PR/issue creation, contradiction events, and approval grants.
Memory diff
How project memory changed during a run — facts added, updated, invalidated; contradictions opened or resolved; stale facts refreshed; handoffs linked.
Contradiction inbox
Collects incompatible facts or conclusions with grouping, evidence, affected artifacts, reviewer assignment, proposed resolution, and the memory update after resolution.
Work graph
Turns chat-like agent runs into durable connected work linking tasks, agents, handoffs, facts, docs, ADRs, branches, issues, PRs, commands, tests, approvals, and artifacts.
Evidence & assumption management
Makes it clear what an agent knows, what it assumes, and what evidence supports each durable assertion — a stronger truth model than ordinary agent memory.
Agent-native onboarding
Lets Codex, Claude, Gemini, and future runners join a project with project model, recent handoffs, policy boundaries, unresolved contradictions, stale-risk warnings, and allowed next actions.
Policy tests & human delegation
Policies are testable. Human approval and clarification are modeled as structured delegation points — not untracked chat interruptions.
Budgets & quotas
Bounds agent work with policy-level budgets for context, model spend, time, writes, commands, retries, parallelism, and approvals.
Instruction distillation
Distills declared instruction files (AGENTS.md,
CLAUDE.md, GEMINI.md, HERMES.md,
SKILLS.md) into structured, scoped, provenance-linked
proposals — never treating raw Markdown as unreviewed truth.
Quality & continuity
Quality gates, recovery mode, runner-capability awareness, known traps, freshness probes, work-product classification, and "what changed since last time" deltas.
Product differentiation
Craik should be described in terms of durable work, not swarm novelty.
Prefer
- Durable agent runtime
- Shared project model
- Governed multi-agent work
- Verifiable handoffs
- Capability receipts
- Memory-native coordination
Avoid
- "Agent swarm"
- "Autonomous everything"
- "One prompt to replace your team"
- "Memory chatbot"
First audience
The first audience is small engineering teams using coding agents on real repositories. They already feel the pain:
Agents repeat investigations
Each session reconstructs context from scratch. No shared model.
Docs lag implementation
Stale docs become traps. No way to surface "this might be out of date".
Chat context disappears
Useful state lives only in a transcript that doesn't survive the session.
Multiple agents step on each other
No coordination layer; no work graph.
Handoffs are informal
"Whatever was in the chat" — instead of typed continuity records.
Governance is human discipline
Policy lives in code review comments, not in the runtime.
Craik should make those failures visible, structured, and fixable.