Shared agent context

Jurati helps every agent come prepared.

Someone records a decision or hands off work. Jurati turns that into team context, so every connected agent starts its next task already knowing what happened.

One handoffthe human signal

Team contexthandled quietly

Connected agentsstart caught up

Input A person says "save this handoff"

1

PersonMarks work worth sharing

2

JuratiFiles the useful context

3

Next sessionAgent starts already caught up

Result The developer using the next agent feels like it 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.

Measured test

Ed records a handoff. Mike's agent already knows.

Two developers, two separate AI sessions, one shared knowledge base. Tested end-to-end with real Claude Code sessions.

repo: AU0035l measured: May 2026

Task-loops GE validation fix

Ed → "I fixed the loop output regex. Save this handoff."

Mike → "I'm starting on the task-review lab. What do I need to know?"

Mike's agent: "The task-loops GE just had its validation false-positive bug fixed — worth looking at that fix as a reference for how to write reliable regex matching against Ansible output."

Mike never asked about task-loops. His agent surfaced Ed's handoff because it was relevant to his work.

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 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

The real question

Team context has to come from somewhere.

The demand is fixed — developers need to know what the team is doing. The variable is the supply path. We measured all of them.

Manual lookup

Open Jira. Search for tickets. Check GitHub PRs. Read Slack history. 10 minutes per question.

Ask a colleague

"Hey Mike, what's the status on task-review?" Interrupts two people. 15–23 min context-switch cost per interrupt.

Pre-loaded context

Agent starts with team state already injected. Zero lookups, zero interrupts. $0.25 per session.

Measured cost

$0.25 per session vs $16 for manual lookup.

Cost per session with 3 coordination questions. Token costs measured from real Claude Code sessions. Time estimates conservative.

Jurati

$0.25

Agent + raw APIs

$2.02

Ask a colleague

$12.96

Manual lookup

$16.16

Standup (amortized)

$19.23

Developer cost: $200K/yr fully loaded = $1.60/min. One minute of human time costs more than an entire Jurati session.

At scale

$54/dev/month vs $1,067 for manual lookup.

Monthly cost per developer. 30% of sessions involve coordination questions. Token costs measured, time costs conservative.

Path	10 devs	50 devs	200 devs	1,000 devs
Jurati	$43	$54	$54	$54
Agent + raw APIs	$107	$133	$133	$133
Standup meetings	$423	$508	$529	$529
Ask a colleague	$684	$855	$855	$855
Manual lookup	$853	$1,067	$1,067	$1,067

Jurati is the only path that scales to O(1) per session regardless of team size. Every other path converts to human time.

The math

Breakeven: 0.23 turns saved per session.

If Jurati prevents even one in four sessions from needing an extra "what's the context?" round-trip, it pays for itself in token savings alone.

Jurati overhead per session

10,380 tokens

One wasted exploration turn

45,000 tokens

The asymmetry

1 minute of developer time: $1.60
1 minute of API tokens: fractions of a cent

The token cost IS the coordination cost. Every other path converts to human time, which is 50–200x more expensive.

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.

Product promise

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

Person

Say what matters in normal language. "Save this handoff." "Record this decision."

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.

20x cheapervs manual lookup

52x cheapervs asking a colleague

$0.25/sessionmeasured token cost

Architecture

Core library + transport adapters.

Jurati is a pure core library with pluggable transport. Files for reads, CLI or MCP for writes, works on any agent client.

File adapterreads via context file

CLI commandsuniversal write path

MCP serverinteractive queries

Transport Adapters

File.jurati/context.md

CLIjurati query / read

MCPinteractive tools

▼

Pure Core Library
schema · index · search · scoring · policy · planning

▼

Git I/Oclone · fetch · commit · push

ProvidersGitHub PRs · Jira

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, content policy, write planning. Zero I/O.

server.pyMCP tool handlers, sync lifecycle, and write orchestration.

cli.pyCLI commands: startup, query, read, record, propose. Same core, different transport.

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

Key boundary: core/ must never import from git/ or providers/ or perform I/O. Enforced by AST guard in the test suite.

File adapter

Context loads before the agent starts.

A SessionStart hook runs jurati startup, writes team context to a file, and the agent reads it naturally. Zero MCP overhead for reads.

hook firesSessionStartagent client starts

CLIjurati startup--format md --output

write.jurati/context.mdteam context as markdown

agentreads the fileno tools, no permissions

Before (MCP-only)

15 MCP tool descriptions: ~735 tokens/turn. Permission prompts on first use. Per-client config required.

After (file adapter)

CLAUDE.md contract: ~50 tokens/turn. Zero permission prompts. Works on any client that can read a file.

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

servefile / CLI / MCPany transport adapter

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

Write path

Every write goes through content policy first.

The content policy gate blocks credentials and enforces review levels. Same WritePolicy.evaluate() whether the write comes from CLI or MCP.

agent intentrecord() / propose()CLI or MCP

policy gateWritePolicy.evaluate()block secrets, enforce level

pure planningplan_record()validate type & level

gitmaterialize_write()commit entry + event

publishpush_active_ref() or push_branch()L0 ref or L1+ PR

Level	Entry Types	Write Mode	Review
`L0`	`active`	`active_ref`	No PR, auto-expires in days
`L1`	`project`	`lightweight_pr`	Small PR, quick review
`L2/L3`	`workflow`, `decision`, `principle`	`review_pr`	Team review required

Knowledge model

Every entry is a markdown file with structured metadata.

Principle

"Never commit secrets to config."

L3 Careful review

Decision

"We chose gRPC over REST."

L2 Team review

Workflow

"How we do release cuts."

L2 Team review

Project

"Auth migration blocked on infra."

L1 Quick review

Active

"Lab 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.

Cross-client

Works on Claude Code, Gemini CLI, any agent.

The file adapter is the universal primitive. Every agent client can read a file. The same context file, the same CLI commands, zero per-client configuration.

Claude Code

SessionStart hook writes .jurati/context.md. CLAUDE.md tells the agent to read it.

Tested & validated

Gemini CLI

Same hook, same file. GEMINI.md has the contract. JSON protocol on stdin/stdout.

Tested & validated

Any future client

If it can read a file and run a shell command, it can use Jurati. No SDK, no plugin, no MCP required.

By design

The hybrid model: files for startup context (zero overhead), MCP for interactive queries (when available), CLI as universal fallback.

Token analysis

Measured: 100K tokens with context, 20K without.

Same 3 prompts, same model, two environments. The "without" session is cheaper but produces no useful coordination output.

With Jurati — 100,669 tokens

"s01 Lecture (PR #13) — Complete, awaiting review. s02 GE (PR #8) — labexec validator was reporting false positives..."

Session cost: $0.15 (bare mode)

Without Jurati — 19,555 tokens

"I don't have much to report, unfortunately... There are no files, modules, or branches related to task-loops present locally."

Session cost: $0.08 (useless)

The agent without context is cheaper but can't answer the question. The developer spends 10 minutes looking it up manually — $16 in human time.

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

cacheSignalCacherefresh interval + recency

classifyclassify_signals()guidance for agents

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

Privacy boundary

Designed to know less, not more.

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

NO

No query loggingThe server does not persist or report query text, read patterns, or search history.

NO

No participation metricsThere is no way to see who viewed an entry or how often agents connect.

NO

No individual activity tracking"What has Ed been working on?" is a query the system refuses by design.

ID

Content policy enforced on writesCredentials, secrets, and sensitive patterns are blocked before they reach git.