Documentation Index
Fetch the complete documentation index at: https://docs.oktolabs.ai/llms.txt
Use this file to discover all available pages before exploring further.
Your first board
This guide walks a single feature — adding a rate-limit to an API — from raw idea to a validated, closed card. Every step uses real Pulse MCP tool names so you can follow along in Claude Code, Cursor, or any connected agent. By the end you will have:- An ideation with a scope assessment
- A derived spec with acceptance criteria, business rules, and test scenarios
- A sprint with cards
- A card closed with evidence and a conclusion
Prerequisites
Your agent needs to callokto_pulse_list_my_boards to discover the board ID it will use throughout this session.
Step 1 — Create an ideation
Ideations are where raw requests land before any design work begins. Paste your request and let the agent structure it. What your agent does:okto_pulse_create_ideation
okto_pulse_get_ideation_context
This returns prior decisions, constraints, and related entities already in the KG. If rate limiting was discussed in a previous sprint, the agent cites it here rather than re-deciding.
Step 2 — Resolve ambiguity
The agent runs the ambiguity-killer protocol: it asks clarifying questions using choice questions (not free text) to zero out ambiguity before advancing. MCP tool called:okto_pulse_ask_ideation_choice_question
okto_pulse_answer_ideation_question
The agent continues until all ambiguous axes are resolved. Open-ended Q&A is also available:
MCP tool called: okto_pulse_ask_ideation_question — for questions that don’t fit a choice format.
Step 3 — Evaluate scope
Before advancing, the agent evaluates the ideation on three axes: domain breadth, ambiguity, and dependency risk. This produces a scope assessment that gates the move to Refined. MCP tool called:okto_pulse_evaluate_ideation
okto_pulse_move_ideation
Step 4 — Derive a spec
Deriving a spec converts the structured ideation into a working document with acceptance criteria, functional requirements, and technical requirements pre-populated. MCP tool called:okto_pulse_derive_spec_from_ideation
Step 5 — Build the spec
The spec is where implementation detail is locked down. The agent adds test scenarios, business rules, and API contracts. Each addition links to specific acceptance criteria.Add a test scenario
MCP tool called:okto_pulse_add_test_scenario
Add a business rule
MCP tool called:okto_pulse_add_business_rule
Add an API contract
MCP tool called:okto_pulse_add_api_contract
okto_pulse_kg_find_similar_decisions
If the team decided on a 429 error format two sprints ago, that decision appears here. The agent cites it rather than re-deciding.
Step 6 — Evaluate and advance the spec
The spec evaluation is a qualitative gate. The agent (or a human reviewer) submits a structured assessment before the spec can advance past Approved. MCP tool called:okto_pulse_submit_spec_evaluation
okto_pulse_move_spec
Step 7 — Create a sprint
A sprint is a time-boxed slice of spec work. The agent can suggest sprint splits or you can define the objective directly. MCP tool called:okto_pulse_suggest_sprints
The agent proposes sprint slices. Accept one or define your own:
MCP tool called: okto_pulse_create_sprint
okto_pulse_submit_sprint_evaluation
okto_pulse_move_sprint
Step 8 — Create and work cards
Cards are the implementation tasks. The agent creates them linked to the active sprint and spec. MCP tool called:okto_pulse_create_card
okto_pulse_link_task_to_scenario
MCP tool called: okto_pulse_link_task_to_rule
When implementation starts, the agent retrieves the full task context before writing any code:
MCP tool called: okto_pulse_get_task_context
This returns the card, linked spec, all business rules, test scenarios, relevant decisions from the KG, and API contracts — the complete picture in one call. The agent uses this to avoid re-reading specs and decisions from chat history.
Move the card through the workflow as work progresses:
MCP tool called: okto_pulse_move_card — not_started → started → in_progress
Step 9 — Close the card with evidence
When implementation is done, the agent closes the card with a structured conclusion. The gate requires a conclusion, a completeness score, and a drift score. MCP tool called:okto_pulse_update_card
okto_pulse_move_card — in_progress → done
The gate enforces: conclusion is required, completeness and drift scores are required, both justification fields are required. The agent cannot close the card without all four.
Step 10 — Update test scenario evidence (optional but recommended)
The test theater prevention gate requires structured evidence before a test scenario can be marked as passing. MCP tool called:okto_pulse_update_test_scenario_status
Step 11 — Close the sprint
With cards closed and evidence recorded, the sprint can close. MCP tool called:okto_pulse_move_sprint — active → review
MCP tool called: okto_pulse_submit_sprint_evaluation — final review evaluation
MCP tool called: okto_pulse_move_sprint — review → closed
What the Knowledge Graph captured
Every decision made during this flow — the Redis storage choice, the 429 response format, the auth-scoped counter rule — is consolidated into the Knowledge Graph automatically. The next ideation that touches rate limiting or Redis will find these decisions and cite them. MCP tool called (automatically by the consolidation pipeline):okto_pulse_kg_begin_consolidation, okto_pulse_kg_add_node_candidate, okto_pulse_kg_commit_consolidation
In the next sprint, when the agent runs:
MCP tool called: okto_pulse_kg_find_similar_decisions
…it will surface the decisions made here. Decisions survive session resets, model upgrades, and team changes. The graph persists; the chat does not.
Agent setup
The agent connection details — registering agents, scoping permissions, and rotating API keys — are covered in Connect your agent.Next steps
ADLC pipeline
The enforced stage machine behind every step in this guide.
Knowledge Graph
How decisions made here persist across sessions.
MCP tool reference
All 198 tools with descriptions and groupings.