Trajectory

Open-source AI mentorship for people serious about who they are becoming.

Most ambitious people do not have an effort problem.

They work hard. They care. They consume books, podcasts, research, and advice. They set goals, make plans, and repeatedly promise themselves that tomorrow will be more intentional.

Then life gets noisy.

The important project is displaced by the urgent request. A difficult hour of focused work becomes forty minutes of email followed by twenty minutes of scrolling. The evening that was supposed to contain training, reading, or building something meaningful disappears beneath the accumulated fatigue of the workday.

Nothing catastrophic happens.

That is what makes the problem dangerous.

A life rarely drifts off course because of one obviously disastrous decision. Direction is lost gradually, through hundreds of reasonable choices that make sense in isolation but point nowhere in particular when added together.

Trajectory is an attempt to build something that notices.

The mentorship gap

Good mentorship is an extraordinary advantage.

A great mentor can see the mistake you are about to spend six months making. They can distinguish necessary persistence from stubbornness, useful detail from perfectionism, and healthy fatigue from the early stages of burnout.

They can tell you when to push.

More importantly, they can tell you when pushing harder is the wrong answer.

Many of us have people who love us, support us, and genuinely want us to succeed. That is not the same thing as having someone who understands the path we are trying to follow and has the experience, context, time, and willingness to continually challenge us along it.

That combination is rare.

The people most qualified to provide this kind of guidance are usually occupied building careers, businesses, families, teams, and lives of their own. Even an exceptional human mentor cannot observe every small tradeoff, remember every commitment, or be available each time we lose perspective.

As a result, capable and driven people can spend years applying enormous effort in slightly the wrong direction.

The problem is not always laziness.

Sometimes it is insufficient feedback.

What is Trajectory?

Trajectory is a local-first, open-source AI mentorship system.

It combines:

• the person you are trying to become;
• the values you refuse to sacrifice;
• your long-term and short-term goals;
• your current responsibilities and constraints;
• the projects and tasks competing for your attention;
• your recent actions and progress;
• evidence from relevant research;
• and principles extracted from people whose judgment you respect.

It uses that context to provide candid, practical mentorship.

Not generic encouragement.

Not another productivity dashboard.

Not an algorithm telling you to squeeze more output from every hour.

The goal is to help you make better decisions about what deserves your effort—and recognize when effort itself is no longer the limiting factor.

The central idea

Most productivity systems measure activity.

Trajectory is interested in direction.

Completing twelve tasks is not necessarily better than completing one. Working late is not inherently admirable. A full calendar does not prove that important work occurred.

The real question is:

Did the way you spent today move you toward the person you said you wanted to become?

Sometimes the answer will be yes.

Sometimes the honest answer will be that you stayed busy to avoid something difficult.

Sometimes the right action will be another focused hour.

Sometimes it will be closing the laptop, eating dinner, going for a run, and getting enough sleep to make tomorrow useful.

Context matters.

Trajectory exists to help interpret that context.

What mentorship should feel like

A useful mentor should not agree with everything you say.

It should be able to tell you:

You are polishing work that is already good enough because finishing it would expose you to judgment.

Or:

This project sounds exciting, but it does not appear connected to the priorities you established for this quarter.

Or:

You are interpreting fatigue as a discipline problem. Based on the last several days, recovery is probably the higher-leverage choice.

Or simply:

I do not have enough information to give you a confident answer.

The system should be direct without being demeaning.

Supportive without becoming flattering.

Ambitious without treating rest, relationships, or health as obstacles to production.

It should critique decisions and patterns—not the worth or character of the person making them.

A council, not a guru

Trajectory does not pretend to be a famous coach, entrepreneur, author, or thinker.

It does not claim to know exactly what another person would do in your situation.

Instead, it can maintain a council of source-grounded perspectives.

Each mentor profile documents:

• the domains in which that person has demonstrated relevant experience;
• principles repeatedly expressed in their public work;
• the sources supporting those principles;
• useful decision-making heuristics;
• the limits and possible blind spots of their worldview;
• and the confidence with which each principle has been interpreted.

A running coach may emphasize consistency, adaptation, patience, and the correct dose of work.

An entrepreneur may emphasize leverage, opportunity cost, repetition, and speed of execution.

A technical leader may emphasize ownership, clarity, influence, and durable systems.

Those perspectives may disagree.

That disagreement is useful.

Trajectory should not average them into generic advice. It should surface the tension, apply your values and circumstances, and explain why one principle appears more relevant than another.

Your mentors contribute perspective.

They do not choose your life for you.

Evidence before certainty

Confident language is easy to generate.

Good judgment is harder.

Trajectory should distinguish among:

• directly sourced mentor principles;
• scientific or behavioral evidence;
• observations from the user’s own history;
• self-reported information;
• tentative patterns;
• and model-generated inference.

A plausible explanation is not automatically evidence.

A repeated observation is not automatically a fact.

A public statement from a mentor is not automatically relevant to every situation.

Recommendations should therefore include their reasoning, relevant sources, meaningful uncertainty, and the information that could change the conclusion.

The aim is not artificial certainty.

The aim is a recommendation strong enough to act on and honest enough to question.

How it might work

Morning

Trajectory reviews your goals, calendar, active projects, deadlines, recent commitments, and current energy.

It identifies:

• the most important outcome for the day;
• the few priorities that support it;
• the distraction most likely to derail it;
• and any recovery or relationship commitment that should remain protected.

During the day

You can ask questions such as:

• Should I spend another two hours polishing this pull request?
• Is this meeting worth attending?
• Am I avoiding the important task?
• Should I train today or recover?
• Which of these projects has the greatest long-term value?
• Am I taking on too much, or making excuses?

The answer should consider opportunity cost rather than evaluating the choice in isolation.

Evening

Trajectory helps you review what actually happened.

Not merely how many boxes were checked, but:

• what moved forward;
• what was avoided;
• what unexpected demands appeared;
• where energy changed;
• whether your actions matched your stated priorities;
• and what should carry into tomorrow.

Weekly

The system produces a trajectory review across the areas of life you care about.

Each area can be assessed as:

• improving;
• stable;
• declining;
• or uncertain.

The report explains the evidence behind that assessment, identifies recurring drift, and recommends one or two meaningful adjustments.

No fake precision.

No life score out of 100.

Just an honest attempt to see the pattern.

What Trajectory is not

Trajectory is not:

• a replacement for real human relationships;
• a substitute for professional medical or mental-health care;
• an imitation of a living person;
• an authority that should be obeyed automatically;
• a covert employee-monitoring system;
• a tool for maximizing every available minute;
• an excuse to outsource personal responsibility;
• or a machine that treats leisure as failure.

The user remains responsible for every decision.

The system’s job is to improve reflection, not eliminate agency.

Design principles

Direction over volume

The amount of work matters less than whether the work points somewhere meaningful.

Fundamentals over hacks

Clear priorities, consistent action, adequate recovery, honest feedback, and repeated reflection should matter more than elaborate optimization.

Patterns over isolated events

One unproductive afternoon is usually noise. Repeating the same avoidance pattern for six weeks is information.

Context over rigid rules

The same behavior can represent procrastination, deliberate recovery, exploration, or genuine constraint. The system should avoid judging an event without understanding its context.

Challenge over flattery

Encouragement is useful when it is earned and specific. Constant praise makes feedback meaningless.

Sustainability over performative intensity

More work is not always better work. Ambition without restraint can consume the conditions required for long-term progress.

Transparency over authority

Advice should show its reasoning, sources, assumptions, and uncertainty.

Privacy by default

Personal goals, journal entries, behavioral data, and daily patterns are sensitive. Local operation, explicit permissions, selective context sharing, and user-controlled deletion should be foundational rather than optional.

Example

You ask:

Should I keep polishing this low-risk pull request tonight?

Trajectory might respond:

I would stop.

You have already spent substantially more time on this than its risk and expected impact appear to justify. Based on your stated goal of developing greater architectural ownership, another two hours here likely has lower value than drafting the first section of the design proposal you have postponed twice.

My concern is not that quality is unimportant. It is that perfectionism may be disguising itself as responsibility.

Recommended next step: write a brief checklist for the remaining PR concerns, resolve only those that could materially affect correctness, and submit it. Spend the next 45 minutes outlining the design proposal.

Confidence: moderate. I do not know whether the pull request contains an unreported production or security risk.

That is the standard.

Specific enough to act on.

Direct enough to matter.

Uncertain where uncertainty is real.

Current status

Trajectory is an early experiment.

The first version is expected to focus on a small number of core workflows:

• editable values, identity, goals, and current-state files;
• source-grounded mentor profiles;
• task and screen-time data imports;
• structured decision reviews;
• morning and evening reflections;
• weekly trajectory reports;
• local memory;
• and a command-line interface.

The first milestone is not autonomous monitoring.

It is a simpler and more important test:

Can an AI combine your goals, current context, documented mentor principles, and credible evidence to give feedback that you genuinely respect?

Until the answer is yes, more integrations will only create a better-informed mediocre coach.

Repository structure

trajectory/
├── desktop/            Electron app: everything runs here
│   ├── src/
│   │   ├── engine/     Mentorship engine, schemas, model providers
│   │   ├── main/       Electron main process, IPC, encrypted stores
│   │   ├── preload/    The only bridge the renderer can see
│   │   ├── renderer/   React UI: today, chat, context, settings
│   │   └── shared/     Types crossing the process boundary
│   ├── tests/
│   └── scripts/        Packaged-app smoke test
├── resources/mentors/  Bundled mentor profiles, principles, sources
├── examples/demo/      Seed configuration copied on first launch
├── docs/methodology/   The constitution and its coverage registry
└── scripts/verify.sh   Typecheck, test, build

Your own goals, values, and history are never in this repository. They are seeded into the OS user-data directory on first launch and edited in the app, which is also where the encrypted chat history and any stored credential live.

Public mentor resources and application code can live in the repository.

Private goals, journals, activity records, and credentials should not.

Roadmap

Phase 1 — Foundations

• Define the values, goals, mentor, evidence, memory, and recommendation schemas.
• Build configuration validation.
• Establish source and attribution requirements.
• Implement local storage.
• Add a deterministic test model.

Phase 2 — Decision mentorship

• Implement the first end-to-end decision-review workflow.
• Retrieve relevant goals and mentor principles.
• Produce structured recommendations.
• Validate claims and attribution.
• Expose the workflow through a CLI.

Phase 3 — Reflection

• Add morning briefings.
• Add evening reviews.
• Add weekly trajectory reports.
• Track commitments, decisions, and outcomes.

Phase 4 — Context

• Add generic task imports.
• Add screen-time exports.
• Add GitHub activity.
• Create adapter interfaces for calendars, Notion, Telegram, and fitness data.

Phase 5 — Carefully designed interventions

• Introduce user-configured notification windows.
• Add cooldowns and confidence thresholds.
• Evaluate repeated patterns rather than isolated behavior.
• Default to silence when context is insufficient.

Contributing

Trajectory should improve through transparent reasoning, not personality imitation.

Contributions are welcome in areas such as:

• application architecture;
• privacy and local-first design;
• mentor-source research;
• evidence review;
• behavioral-data adapters;
• prompt evaluation;
• recommendation-quality testing;
• accessibility;
• documentation;
• and user-experience design.

Mentor profiles must:

• rely on public or properly licensed sources;
• cite the material supporting each principle;
• separate direct statements from interpretation;
• avoid fabricated quotations;
• document uncertainty;
• acknowledge likely blind spots;
• and avoid presenting a living person as if they endorsed this project.

The larger goal

There is no system that can guarantee a meaningful career, a strong relationship, athletic progress, creative success, or a well-lived life.

There is no prompt that removes uncertainty.

There is no mentor—human or artificial—who always knows the right answer.

But better feedback changes outcomes.

So does asking the right question before months of effort accumulate behind the wrong one.

Trajectory is built around the belief that more people should have access to thoughtful challenge, experienced perspective, and consistent reflection—not only those fortunate enough to find the perfect coach, manager, collaborator, or mentor at exactly the right moment.

You still have to do the work.

You still have to make the decision.

You still have to live with the tradeoff.

Trajectory is there to help make sure the work is pointed in a direction you deliberately chose.

---

Technical appendix

Trajectory is an Electron desktop app written entirely in TypeScript. The mentorship engine runs in the Electron main process — there is no sidecar and no second runtime. It supports a deterministic local demo, the GitHub Copilot SDK, and OpenAI-compatible providers.

Run it

Requires Node.js 22.12 or newer.

npm install --prefix desktop
npm run dev --prefix desktop

Create an unpacked build with npm run package --prefix desktop.

On first launch the app copies the synthetic demo configuration into its user-data directory and reads from there afterwards. Those files are yours to edit; nothing writes them back and nothing commits them.

Platform	Where your configuration lives
macOS	~/Library/Application Support/Trajectory/config/
Windows	%APPDATA%\Trajectory\config\
Linux	~/.config/Trajectory/config/

Each mentor directory contains a profile, grounded principles, and approved source records. An optional voice.yaml adds tone, cadence, selective patterns, avoidance rules, and response-construction guidance without changing what the mentor believes. At runtime Trajectory sends only the compact chat guidance and one or two relevant synthetic examples. Real-person simulations remain independent, disclosed, and not endorsed by the person they model.

The deterministic provider answers only the committed synthetic pull-request scenario. Choose Copilot or an OpenAI-compatible provider for anything else.

The Copilot provider ships the Copilot runtime inside the application, so it needs no separate install — sign in to GitHub Copilot and it works. It defaults to the auto model; set COPILOT_MODEL to name a specific one. The OpenAI provider reads OPENAI_API_KEY and OPENAI_MODEL from the environment, which means it currently works when the app is launched from a shell but not when launched from Finder. In-app credential storage is on the backlog.

Architecture and privacy

Trajectory loads only the user and mentor directories it is handed, selects the relevant goals, principles, and sources, asks the chosen provider for a structured response, and validates every referenced identifier in both directions before showing you anything.

The Electron renderer has no filesystem or process access. A narrow preload bridge sends validated requests to the main process, which owns the encrypted conversation store and the engine. The app refuses to persist chat history if operating-system encryption is unavailable rather than quietly writing plaintext.

Copilot and OpenAI-compatible providers receive the selected context under their own processing and retention policies. Trajectory does not silently switch providers or ingest messages, calendars, screen time, employer systems, or other private sources.

Development

npm install --prefix desktop
npm run typecheck --prefix desktop
npm test --prefix desktop
npm run build --prefix desktop

Or run the whole chain fail-fast with ./scripts/verify.sh.

The chain does not package the app, and packaging does not launch it. When a change touches the preload, window creation, packaging, or how a provider reaches its runtime, run the packaged smoke test too:

npm run package --prefix desktop && npm run smoke --prefix desktop

It copies the built app outside the repository, launches it against a throwaway user-data directory, and drives the real preload bridge — the only check that catches a build which is green everywhere else and broken once installed.

Keep private configuration, credentials, chat history, and generated application data out of Git. Behavior changes should preserve the provider-independent contracts and include focused tests.

Working with agents

This repository is developed through the GitHub Copilot desktop app and CLI, and it carries a small governance stack so that work is consistent regardless of which agent does it.

docs/methodology/CONSTITUTION.md is the single source of truth — 32 rules, each traceable to a real defect or an explicit product decision, and each with a stable [HC-*] slug that agents must cite verbatim. coverage-gaps.md records honestly which of those rules nothing actually checks.

AGENTS.md is the router: it holds no rules, only the read order and a path-to-rule table so .github/instructions/* load lazily based on the files being touched.

Four agents split the work by privilege — plan cannot edit, implement refuses to start without captured baseline evidence, verify cannot fix what it finds, and review cannot write and runs on a different model vendor from the author. Skills: /verify, /reflect, /cap.

There is no CI and there are no hooks. That is deliberate for a project this size; the rules are held up by agent refusal contracts, the test suite, and review.

The active backlog is maintained in Future iterations. Trajectory is licensed under the Apache License 2.0.