Kimtu
Try with your repo
System context layer

A shared source of truth for your architecture and documentation.

Architecture, documentation and system context in one place — for the developers who browse it and the agents that write it.

Try with your repositoryExplore an example
No GitHub connection · Your source stays on your machine
components in the example
15
connections mapped
26
documentation pages
15
DeveloperBrowses the context to understand the system.
AI agentWrites the context from the repository it is already reading.
Product

One system. Two ways to use it.

Developers

Understand the system

Components, connections and docs in one connected view.

  • Component catalog15 components
  • Connections26 mapped
  • Documentationdocs/
  • Ownership6 teams
AI agents

Build with context

Your coding agent writes the structure Kimtu draws. Reading it back, before it plans a change, is where this is going.

context recordNot shipped yet
component: invoice
  type: service
  owner: billing-team
  docs: docs/overview.md
  calls: customer, pg-invoices
  publishes: invoice.created, invoice.finalized
  consumed by: ledger, notification
Every component, listedOne index of what exists: each service, application, database, queue and external system, with what it is for.
Connections you can readUpstream and downstream on one diagram, with the contract on every edge — endpoint, event or datastore.
Docs from the repositoryThe markdown under docs/ renders as pages, with its source path on each one. Only if you choose to share it, and never source code.
Context, not autocomplete

A codebase is not the fastest way to understand a system.

Architecture, ownership and data flows are rarely written in the files an agent opens. Kimtu keeps them in one structured place.

Without system context
  • Rebuilds the architecture from files every task
  • Guesses which component owns a behaviour
  • Misses dependencies and published events
  • Plans against assumptions
With Kimtu context
  • Reads the relevant components and docs directly
  • Knows the owner, the technology and the contract
  • Sees upstream callers and downstream consumers
  • Plans against what the system does
How it works

The knowledge already exists. Kimtu structures it.

  1. 01Start a sessionNo account, no install. One click gives you a prompt for your coding agent.
  2. 02Your agent reads the repositoryClaude Code, Cursor or Codex reads the code on your machine and writes kimtu.yaml. No source code is sent.
  3. 03Markdown becomes pagesThe files under docs/ render as pages if you choose to share them, and their headings become the rail.
  4. 04The graph draws itselfDeclared relationships, with their endpoints and data, become edges between components.
orders-service/kimtu.yaml
apiVersion: kimtu/v1
repository:
  id: orders-service
  name: Orders Service
components:
  - id: orders
    name: Orders Service
    type: service
    relationships:
      - to: payments
        endpoint: POST /payments
      - to: inventory
        endpoint: POST /reservations
      - to: orders-db
        interaction: postgres
      - to: payment-events
        interaction: sqs
        direction: inbound
becomes the page below, plus 4 edges on the graph
Orders Serviceservice
orders · kimtu.yaml · 4 connections
  • CallspaymentsPOST /payments
  • CallsinventoryPOST /reservations
  • Callsorders-dbpostgres
  • Consumespayment-eventssqs
Where this is going

Built for the agentic development era

The agent-assisted import is how architecture gets in today. The destination is a knowledge layer developers browse and agents consume continuously.

MVP
AI-assisted architecture definition
Vision
A living knowledge layer for developers and AI agents
Today
RepositoryCoding agentKimtu
A one-time, agent-assisted import.
Where we’re goingNot shipped yet
Kimtu · architecture + knowledge
DevelopersAI agents
Context kept current in the workflow, read by the agent as it works.
Architecture

Start at one service, follow the edges

Every component page carries its own neighbourhood: what calls it, what it calls, and the contract in between.

Open the example
API GatewayBilling Cron
Invoice Service
Customer ServiceEvent BusPostgres · invoicestax-rates
UpstreamSelected componentDownstream
Service overviewWhat it does and what it talks toConnectionsEdges with their contracts
Your repositoryMap it with your coding agent
Help shape Kimtu

Built with developers, not just for them.

Kimtu is early. Tell us what would make it useful for your team.

Would this be useful to your team?
Stay in the loopOptional. Get occasional updates as we build Kimtu.
Feedback or an email address — either is enough.