Vision
Why this doc matters
Every other doc in this section is downstream of the vision. Read this first to understand the thesis, the product category Craik is creating, and the north star that decides what ships and what doesn't.
Craik exists to make agent work durable.
Current agent tools are improving quickly, but most still treat useful state as a side effect of a chat transcript, terminal log, or ad hoc summary. That does not scale to teams, long-lived projects, or multi-agent workflows.
Craik's central claim is that agents need an operating layer that gives them:
A shared model of the work
Agents inherit the same case file, evidence, ADRs, traps, and contradictions before they act.
Evidence-backed memory
Every durable assertion cites a source. Proposals flow through review; nothing silently overwrites truth.
Explicit authority boundaries
Policy envelopes, capability grants, and immutable paths decide what an agent may touch — not the agent's intuition.
Structured handoffs
Machine-readable continuity records the next actor can resume from. No re-deriving state from chat logs.
Durable artifacts
Receipts, work-graph nodes, and exports survive the run — addressable for audit and replay months later.
A way to resolve disagreement
Contradictions are first-class workflow items, not silent merge conflicts.
Product category
Craik should not be positioned as another agent framework.
The intended category is:
Durable agent runtime.
An agent framework helps developers wire agents to tools. A durable agent runtime helps agents participate in long-running work with continuity, accountability, and shared state.
North star
A new agent should be able to join a project and understand its current state better than a human who has been away for two weeks.
That includes:
Current goals
The task queue, the active intent locks, and the accepted interpretations.
Active branches
Repo state, recent commits, default branch, dirty-vs-clean status.
Relevant issues & PRs
Open issues, PRs in review, comments and check results — all loaded as evidence.
Architecture constraints
Immutable ADRs, design decisions, and the reasons behind them.
Stale docs & known risks
Stale-risk markers, known traps, and negative knowledge from prior runs.
Accepted conventions
Validation commands, allowed autonomy, scope rules.
Unresolved questions
Open contradictions, missing context flagged in case files, exit-discipline context requests.
Facts other agents learned
Stigmem-backed truth, with provenance and trust scope — not just chat transcripts.
Design principles
The six principles every Craik feature is measured against.
Memory is not a transcript. Durable memory should be structured, scoped, provenance-aware, and reviewable.
Agents should not silently rewrite reality. Contradictions become first-class workflow items, never silent merge conflicts.
Context should be assembled, not dumped. Agents receive task-specific case files that explain what matters and why.
Governance belongs in the runtime. Permissions, approvals, policy obligations, and receipts are part of normal execution — not an enterprise add-on.
Handoffs are artifacts. A final chat message is not enough. Agent work leaves structured state for future agents.
Local mode should exist, but not define the product. Craik should be easy to try without Stigmem, while making clear that durable multi-agent work needs a real memory substrate.
Initial wedge
The first market wedge is multi-agent software delivery for small technical teams. Concrete enough to prove the runtime — every piece of the thesis is observable in software delivery:
Repositories have history
Git provides the durable substrate Craik's project model reads against.
ADRs and docs go stale
Stale-risk and contradictions are inherent — not edge cases.
CI and PRs create verifiable artifacts
Verification commands, check results, and review state are first-class.
Issues encode work
Task surfaces already exist, so Craik's task contract has real grounding.
Agents need context
Software work is context-heavy. Case files demonstrate value immediately.
Handoffs matter
Teams already feel the pain of "what did the last person mean"; structured handoffs land naturally.
If Craik works here, it can expand into incident response, research operations, compliance workflows, support engineering, and other long-running knowledge work.