Shared agent context

Jurati helps every agent come prepared.

Someone labels a pull request. Jurati turns that into team context, so every connected agent starts its next task already knowing what happened.

One PR labelthe human signal

Team contexthandled quietly

Connected agentsstart caught up

Ambient input A person labels a PR with jurati

1

PersonMarks work worth sharing

2

JuratiFiles the useful context

3

Connected agentsStart already caught up

4

OutcomePeople get better guidance

Result The person using the next agent feels like the agent came prepared.

The problem

Where team context lives today

Today, people coordinate through Slack, issues, meetings, and memory. Then they re-explain it all to each new agent session.

Meeting notes

Decisions made verbally, written down if someone remembers, scattered across docs nobody searches.

Slack threads

Context buried in chat history, hard to find a month later, no structure.

People's heads

When someone's on PTO or leaves, their context leaves with them.

AI agents make this worse. They start every task with zero team context -- just the code in front of them.

Plain example

The human move is simple: label the PR.

Alice labels her auth migration PR so the team remembers it. A day later, Bob's agent tries to edit the same files.

repo: api-service signal: jurati label

Auth session migration

Alice -> adds the jurati label to PR #42

Bob -> asks his agent to edit auth/session.py

Agent -> sees the labeled PR before editing

Alice has an open auth migration. I should wait, or build on that branch, instead of creating a conflicting change.

Usage

How developers interact with it

No new UI to learn. Developers record decisions through their existing AI coding assistant.

"Save this as a team decision"

"We decided to standardize on AAP 2.6 terminology across all AU-prefixed courses."

Recorded the terminology decision.

"Hand this off for the next person"

"Lab scripts are done, but the DNS issue on workstation is still open."

Saved the handoff.

Git-backedfull audit trail

Reviewabledecisions go through PR

Auto-expireshandoffs stay clean

Agent integration

What AI agents see when they start a task

Before reading code or making changes, the agent checks what the team already knows.

Without team knowledge

Agent builds a lab using old terminology. Developer catches it in review. Work gets redone.

With team knowledge

Agent reads the terminology decision before starting. Uses the right terms from the start.

Without handoffs

Developer picks up a task cold. Spends 30 minutes figuring out what was already done and what's blocked.

With handoffs

Agent reads the handoff note. Immediately tells the developer what's done, what's open, and what to avoid.

What Jurati does today

It gives the agent team context before work starts.

Looks first

Before a task, the agent checks current work, decisions, workflows, and labeled PRs.

Finds specifics

The agent can search by topic or pull up a specific entry when it needs detail.

Remembers handoffs

Short-lived notes cover blockers, current focus, or what to look at next.

Saves decisions

Important decisions and workflows go through team review before they stick.

Stays current

The server syncs from git on every session, so context is always up to date.

Knowledge model

You speak normally. The agent figures out what kind of knowledge it is.

The person never picks a type or level. The agent reads what was said and categorizes it, which determines how it gets stored and reviewed.

Principle

"Never commit secrets to the config repo."

L3 Careful review

Decision

"We decided to use gRPC instead of REST."

L2 Team review

Workflow

"Here's how we do release cuts."

L2 Team review

Project

"Auth migration is blocked on infra."

L1 Quick review

Active

"Lab scripts done, DNS still broken."

L0 Temporary

L0Temporary

Pushes directly, auto-expires in days. No PR, no review.

L1Quick review

Creates a lightweight PR. Low-stakes, usually merged quickly.

L2Team review

Creates a PR that needs team sign-off before it sticks.

L3Careful review

Highest-stakes content. Requires deliberate team approval.

Privacy boundary

People choose what gets broadcast.

Nothing enters the system unless someone explicitly shares it -- a labeled PR or a deliberate save through the agent.

NO

No broad miningUnlabeled PRs, chats, editor activity, and comments are never collected.

NO

No read receiptsNobody can see who viewed what. There is no engagement dashboard.

NO

No presence trackingGit history exists for accountability, not to measure participation.

ID

Sensitive notes stay quietRestricted entries are hidden from search and startup context.

Impact

What changes for the team

Context survives transitions

When someone goes on PTO or a new member joins, decisions and project state are already recorded and searchable.

Less rework from AI agents

Agents read team decisions before starting work. Wrong terminology, outdated patterns, and re-debated decisions are reduced.

Explicit handoffs

"Ask Sarah, she was in that thread" becomes a searchable, structured entry with status, blockers, and next steps.

Auditable decisions

Every decision is a file in git with full version history. You can see who decided what, when, and why.

Product promise

The visible experience is simple: the agent is already caught up.

Person

Add the jurati label to PRs worth sharing. Say what matters in normal language.

Agent

Start with team context and use it to guide the person when it matters.

Jurati

Handle the filing, review, search, and privacy work in the background.

How Jurati works

A PR label becomes shared agent context.

Jurati is an MCP server backed by a git repository. Every agent that connects to the same repo gets the same team context before it starts working.

MCP serveragent-facing API

Git reposource of truth

PR labelscoordination input

Inputs

Agent asks for contextcontext(repo, goal, paths)

Person labels a PRlabel: jurati

Agent translates intentrecord / propose

Outputs

Session contextrecent + active + guidance

Knowledge PRreviewable write path

Privacy boundaryexplicit signals only

Runtime boundary

People never touch the API. Agents handle it.

A person labels a PR or talks to their agent in plain language. The agent calls Jurati's MCP tools behind the scenes.

1

Agent connects to server.py over MCP.The server clones (or reuses) the knowledge repo, fetches the latest state, and builds an in-memory index.

2

Agent calls sync() then context().Built-in instructions tell the agent to do this before any work, then summarize what matters to the person.

3

Agent may call record() or propose().Write APIs the agent uses on behalf of the person -- no extra commands for the person to learn.

Read path

Context comes from git, served through an in-memory index.

Git is the source of truth. The server keeps only local state it can rebuild from scratch: a repo cache and an in-memory search index.

clone/cacheensure_repo()cache path is remote hash

fetchfetch_all()main plus active refs

parseload_index_from_repo()markdown + YAML frontmatter

indexIndex + BM25rebuilt on sync

servecontext() / search()MCP responses to agents

Key boundary: all indexing and ranking logic is pure -- no network, no git calls, no filesystem access. I/O lives in separate modules.

Knowledge model

Every entry is a markdown file with structured metadata.

Each entry has a type, a review level, and an expiration policy, so the system knows how to store, surface, and retire it.

Type	Default Level	What It Means
`active`	`L0`	Short-lived note (handoff, current focus). Expires automatically.
`project`	`L1`	What's in progress, blocked, or changing soon.
`workflow`	`L2`	How the team does something -- reviewed before it sticks.
`decision`	`L2/L3`	A choice the team made, with the reasoning behind it.
`principle`	`L3`	A lasting engineering rule or standard.

Ambient PR signals

Only labeled PRs from configured repos enter the system.

Jurati watches specific repositories for PRs carrying the jurati label. Everything else is ignored by design.

configJURATI_PR_SIGNAL_REPOSonly configured repos

providerfetch_labeled_prs()gh api search/issues

normalizePRSignaltitle, author, state, labels, paths

cacheSignalCacherefresh interval + recency

contextclassify_signals()guidance returned to agent

No unlabeled PRs, comments, chats, editor activity, or broad repo mining enter this path.

Coordination classifier

PRs turn into concrete guidance, not generic alerts.

The classifier checks whether the PR overlaps with what the agent is about to do, then returns a specific recommendation with evidence.

pauseAn open PR touches the same files. The agent should hold off or coordinate.

reuseA merged PR already changed this area. The agent should build on that work.

reviseThe PR describes a decision, migration, or architecture change worth reading first.

handoffSomeone is waiting, blocked, or handing off ownership of this area.

continueSame repo but different area. Noted as background context, no action needed.

clarifyMight be relevant, but unclear. The agent asks only if the ambiguity blocks a safe plan.

EvidenceEvery recommendation comes with the PR number, URL, author, matched paths, and reasoning.

PrivacyThe privacy boundary is stated alongside every set of results.

Search and context

Search ranks by relevance and recency. Restricted entries are excluded entirely.

search() uses BM25 scoring weighted by recency, entry type, and repo affinity. query() tries exact topic matching first, then falls back to ranked search.

# src/jurati/core/scoring.py
combined =
  bm25
  * recency_half_life_14_days
  * type_weight
  * repo_affinity
  * exact_match_boost

restricted entries:
  excluded before BM25 index construction

title text:
  weighted by appearing three times in document text

Write path

Nothing writes directly to main. Every change goes through git.

The core logic plans what to write. A separate git layer turns that plan into commits, branches, and pull requests.

agent intentrecord() / propose()typed MCP call

pure planningplan_record() / plan_propose()validate type and level

intentWriteIntentpath, content, branch, write mode

gitmaterialize_write()commit entry and event

reviewcreate_pr()PR or branch-only fallback

Level	Entry Types	Write Mode	Review Behavior
`L0`	`active`	`active_ref`	Pushed to a short-lived ref. No PR, auto-expires.
`L1`	`project`	`lightweight_pr`	Creates a small PR for quick review.
`L2/L3`	`workflow`, `decision`, `principle`	`review_pr`	Creates a PR that requires team review before merging.

Privacy boundary

The system is designed to know less, not more.

Jurati broadcasts what people choose to share. It cannot observe what they don't.

NO

No broad miningOnly repos you configure are watched, and only labeled PRs are read.

NO

No read receiptsThere is no way to see who viewed an entry or which agent read it.

NO

No participation trackingGit history exists for accountability, not to score engagement.

ID

Restricted entries are invisible to searchThey don't appear in context or search results. You can still fetch one directly if you know its ID.

Engineering shape

The codebase separates logic from I/O.

Policy decisions, server orchestration, external data sources, and git operations each live in their own module with clear boundaries.

core/All the rules: schema, validation, indexing, search ranking, signal classification, write planning. Zero I/O.

server.pyThe glue: MCP tool handlers, sync lifecycle, search cache, and write orchestration.

providers/External data adapters. GitHub PRs today, with a protocol interface for adding more sources.

git/Everything that touches the filesystem: clone, fetch, branch management, commits, and PR creation.

Agents get a stable API. Teams get a reviewable git repo. People keep using their normal PR workflow.