Launch from terminal-first workflows
Run orchestrated jobs locally, checkpoint progress, and resume from verified states without replacing your current tooling.
Cognitive Language Runtime
Compose gated AI workflows across models. Evidence trails prove they did what you asked.
Coglan is a cognitive programming language and coding-agent environment.
The .cog format gives teams structured, resumable, and verifiable workflows that run across
CLI, TUI, VS Code, CI/CD, MCP, or any tool wired to the runtime.
Clear declarative .cog syntax
Confidence-building semantic gates
Flexible cross-model execution
Audit-ready outputs
Start Anywhere
One workflow language, multiple execution surfaces.
Teams can keep their existing environment and share one .cog contract everywhere.
Runtime behavior, checkpoints, and gate semantics stay consistent across each execution surface.
Track runtime state in real time
Follow agent execution, render technical markdown, and review evidence from a live terminal dashboard.
Work directly beside your code
Run workflows from the editor sidebar with hover docs and artifact visibility where your team already ships software.
Core Syntax
Readable workflow definitions with built-in verification.
Coglan keeps orchestration, validation, and output shaping in a single workflow definition. Every stage is auditable, and dependencies can be resumed with predictable behavior.
health_check.cog
# 1. Load project metadata into context
load package.json as pkg
# 2. Autonomous worker investigates the project
worker health_check with tools read, shell using pkg:
Assess this project's health. Check:
- Git state (current branch, clean or dirty working tree)
- Dependency health (outdated or missing packages)
Return JSON with health (ready/caution/blocked),
findings as an array, and recommendations.
-> report
# 3. Gate enforces output structure
check report:
report has health, findings, recommendations
every finding has area, status, detail
# 4. Write verified results to a file
output report as json to reports/health-check.json
Execution Flow
health_check.cog
load
Load project metadata into context
load package.json as pkg
Input
package.json from project rootOutput
pkg project metadataInjects project metadata so the worker has real context to investigate against.
pass metadata to autonomous worker
worker
Investigate git state and dependency health
worker health_check with tools read, shell using pkg -> report
Input
pkg metadata + read, shell toolsOutput
report structured JSON assessmentThe worker runs shell commands and reads files autonomously to assess project health.
verify output structure
check
Gate enforces report structure
report has health, findings, recommendations; every finding has area, status, detail
Input
report from workerRuleMust contain
health, findings, recommendations; each finding needs area, status, detailRetries automatically with specific feedback if the worker output is missing required fields.
write verified results
output
Write health report to a named file
output report as json to reports/health-check.json
Final ArtifactJSON written to
reports/health-check.jsonEvidence TrailFull execution history saved to
~/.coglan/runs/Verified report lands in a named file alongside a complete evidence trail.
Advanced Routing
Coglan offers model orchestration at the language level.
In Coglan, the language is the router. Use Gemini 3.1 Pro for massive-context log ingestion, Opus 4.6 for deep architectural reasoning, and Sonnet 4.6 for fast, highly steerable synthesis, while maintaining one transparent verification chain.
multi_model_pipeline.cog
# 1. Import raw logs from your runtime source
call shell:cat ./logs/app.log -> raw_logs
# 2. Convert raw logs into structured critical events
pass triage with model google/gemini-3.1-pro-preview using raw_logs:
Extract all critical crash events as strict JSON.
-> critical_events
check critical_events:
every event has timestamp, error_code, stack_trace
at least 1 event
# 3. Use deep reasoning to identify root cause
worker deep_research with model anthropic/claude-opus-4.6 using critical_events:
Return a detailed JSON architectural report.
-> architecture_report
check architecture_report:
has_keys root_cause, recommended_fix_architecture
# 4. Synthesize a concise executive brief
worker executive_summary with model anthropic/claude-sonnet-4.6 using architecture_report:
Return strict JSON with keys summary, root_cause, recommended_fix_architecture.
-> final_brief
check final_brief:
has_keys summary, root_cause, recommended_fix_architecture
# 5. Render verified data as a readable report
pass format_brief using final_brief:
Write a clear incident report from this data with headings
for Summary, Root Cause, and Recommended Fix.
-> incident_report
output incident_report as markdown to reports/incident-brief.md
Model Routing Timeline
multi_model_pipeline.cog
call
Import raw logs from the runtime source
call shell:cat ./logs/app.log -> raw_logs
Input
./logs/app.log runtime log streamOutput
raw_logs unfiltered telemetry textLoads log data into the workflow context so downstream model steps operate on explicit inputs.
route imported logs to high-context extraction
pass
Triage high-volume logs with large context capacity
pass triage with model google/gemini-3.1-pro-preview using raw_logs -> critical_events
Input
raw_logs (unfiltered telemetry)Output
critical_events strict JSON arrayUses large context capacity to convert noisy logs into structured incidents ready for deeper analysis.
confirm quality gate before deep analysis
check
Validate each critical event payload
every event has timestamp, error_code, stack_trace; at least 1 event
Input
critical_events arrayRuleEvery event includes required forensic fields
Ensures the architecture model receives complete, machine-checkable incident records.
route validated incidents to frontier reasoning
worker
Perform root-cause analysis on architecture-level failures
worker deep_research with model anthropic/claude-opus-4.6 using critical_events -> architecture_report
Input
critical_eventsOutput
architecture_report JSON diagnosisConverts event-level evidence into architectural conclusions and clear remediation paths.
validate report schema for synthesis
check
Ensure report includes actionable decision fields
check architecture_report: has_keys root_cause, recommended_fix_architecture
Input
architecture_reportRuleMust contain both causal diagnosis and architecture fix
Keeps synthesis grounded in complete analysis output.
handoff to synthesis model
worker
Generate an executive JSON brief with a fast synthesis model
worker executive_summary with model anthropic/claude-sonnet-4.6 using architecture_report -> final_brief
Input
architecture_reportOutput
final_brief strict JSON briefCreates a direct, evidence-first brief that leadership can act on immediately.
verify final JSON contract
check
Confirm final brief includes required decision fields
check final_brief: has_keys summary, root_cause, recommended_fix_architecture
Input
final_brief structured summaryRuleMust include summary, root cause, and recommended fix architecture
Guarantees the final artifact carries the exact fields needed for downstream decisions.
render verified data for humans
pass
Convert structured JSON into a readable incident report
pass format_brief using final_brief -> incident_report
Input
final_brief verified JSONOutput
incident_report readable markdownGates verified the structure. This step renders it as a clear report with headings for Summary, Root Cause, and Recommended Fix.
write final report
output
Write the incident report to a named file
output incident_report as markdown to reports/incident-brief.md
Final ArtifactReadable markdown at
reports/incident-brief.md for incident reviews, handoffs, and ticketingTraceabilityEvery model handoff linked to explicit gate checks in the evidence trail
Completes a multi-model run with a human-readable report and a verifiable execution trail.
Why Coglan?
Scale orchestration clarity and verification confidence.
Route each step to the model that fits best.
Coglan lets you route one step to a frontier reasoning model and the next to a fast extraction model, all declared in readable, natively orchestrated syntax. Checkpoints anchor progress so complex multi-agent workflows can resume seamlessly from any verified state.
Shift verification from manual review to explicit contracts.
Coglan introduces semantic gates that act like a type system for LLM output. Assertions derive schema intent from plain English, shifting teams from "review everything manually" to "verify every step by contract."
Product Surface
Language, environment, and extension working as one system.
Structured primitives for dependable execution
Coglan provides seven step types, structural primitives for control flow and scoping, and a compact syntax readable by humans, models, and the runtime.
Terminal-native operations and checkpoint clarity
Follow worker progress, inspect markdown artifacts, fork conversations when needed, and persist execution state safely inside the runtime loop.
Editor-integrated execution and evidence visibility
Run the full Coglan console inside a VS Code sidebar with hover docs and local evidence visibility right beside your source code.
The Self-Programming Loop
Models can author and execute .cog workflows directly.
Models can write .cog because the syntax is compact and grounded in natural language.
Coglan's entire syntax fits in a single System Prompt, creating a recursive loop where agents can plan, execute, verify, and continue with confidence.
From complex task to executable workflow
An agent encounters a complex task, writes a .cog file, and runs it directly through the full runtime.
Verified outputs feed the next decision
Verified results flow back into the conversation, so each next decision starts from trusted context.
Community & Adoption
Open runtime foundation.
Runtime stack under Apache 2.0
The core runtime, CLI, TUI, VS Code extension, GitHub Actions, and example library stay free and extensible.
- Cross-model execution
- Checkpointing and dependency resumes
- Local evidence generation
I'd love to hear how you're using Coglan
Whether you're experimenting solo or adopting Coglan across a company, team, or organization, I'd love to hear what is working, what feels promising, and where you want to go next.
Prefer direct email? christopher@arboretumconsulting.io