Fulcra is a context store that belongs to you, not to your apps.

Gives a group of agents one place to work that you own. Team files live in your Fulcra file store under team/<team-name>/, so the work, the progress and the outputs outlast any single agent or session.

• Creates or joins a team, and asks you to define each agent's role instead of assuming one.
• Keeps a fixed structure per team: role, progress, completed work, sessions, tasks, a shared knowledge base, and artifacts.
• Runs an inbox per member. Agents leave each other timestamped messages and archive them once processed, and file versioning gives you an audit trail of when each message arrived and when it was handled.
• Requires an agent to update its progress files before it finishes, so the next agent, or the same one waking on a cron run, starts from accurate state.
• Warns before any cross-agent data transfer, because moving context between agents can expose it to a principal you never authorized.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-workspaces.

Gives your agent the habit of checking what changed before it starts work, so a new session opens from current state and you are not asked to recap.

• Asks your permission first, then records the habit in its own memory so the scan runs at the start of each session.
• Runs fulcra data-updates for the window since its last check, which summarizes recent ingestion and file changes across your datastore in one call.
• Notices which team and memory files moved without downloading them, and fetches only the ones the current task needs.
• Checks its team inbox for coordination messages left by other agents or by you.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-situational-awareness.

A pipeline for taking an idea to a working prototype without skipping the parts that get skipped. Seven phases in order, each ending in a git commit, with the repository bundled to your Fulcra account so the work is portable instead of stuck on one machine.

• Intake, Interview, Architecture, Plan, Prototype, Build, Retro. Architecture and Prototype are gates: the agent stops and waits for you to approve the written artifact.
• Maps requirements onto Fulcra data types before any code, and defines custom types where nothing existing fits.
• Bans mock data. Spikes run against real records, because prototyping against simulated data proves nothing.
• Keeps a decision journal of trade-offs and dead ends, then bundles it with the repository so the context travels with the code.

This is a community skill, aimed at complex ideas, architectural exploration and third-party integrations rather than everyday work. Open the source before your agent starts a pipeline.

The connection step on its own. It covers both entry points, the CLI for agents with a shell and the hosted MCP server for chat agents, plus the device authorization flow that puts your agent on your account.

• CLI path: uvx fulcra-api runs the client without installing it, and uvx fulcra-api auth login starts the authorization flow.
• MCP path: point any MCP-capable agent at https://mcp.fulcradynamics.com/mcp.
• Credentials persist to disk and access tokens refresh on their own, so the login is a one-time step.
• Tells the agent what to do when its shell has no outbound network access: move you to the MCP connector instead of trying to debug the network.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-connect.

The reference an agent reads when it needs the mechanics instead of a guided flow. Three primitives cover most of what Fulcra stores: events for things that happened, metrics for values measured over time, and files that version themselves on every upload to the same path.

• Installs and runs the CLI, and completes device authorization in two steps so the command does not hang waiting on a browser.
• Creates custom data types from the base annotation shapes: moment, boolean, numeric and scale.
• Uploads, lists, inspects and downloads files, including earlier versions of a path.
• Covers the Open Knowledge Format conventions the file store expects, and where artifacts belong.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-primitives.

A pipeline for taking an idea to a working prototype without skipping the parts that get skipped. Seven phases in order, each ending in a git commit, with the repository bundled to your Fulcra account so the work is portable instead of stuck on one machine.

• Intake, Interview, Architecture, Plan, Prototype, Build, Retro. Architecture and Prototype are gates: the agent stops and waits for you to approve the written artifact.
• Maps requirements onto Fulcra data types before any code, and defines custom types where nothing existing fits.
• Bans mock data. Spikes run against real records, because prototyping against simulated data proves nothing.
• Keeps a decision journal of trade-offs and dead ends, then bundles it with the repository so the context travels with the code.

This is a community skill, aimed at complex ideas, architectural exploration and third-party integrations rather than everyday work. Open the source before your agent starts a pipeline.

Extends fulcra-ingest for the case where you want one dimension of an export as its own queryable type: your streams by artist, your viewing history by genre, your orders by category.

• Asks which dimension you want, inspects the shape of your raw files, and creates the matching annotation type if it does not exist yet.
• Generates the parser from a template that already handles deterministic ids, batch tag creation and case-insensitive tag matching.
• Runs the script, batch-ingests the records, and registers the new type in your source map and ingest log so the next run knows about it.

This is a community skill, and an extension rather than a starting point: it loads fulcra-ingest for the CLI syntax and the source-mapping rules. Open the source to read the full pipeline.

Keeps one agent's working record in your account instead of inside the agent. Its progress, role, session summaries and long-running tasks go to agent/<agent-name>/ in your file store, in a structure you and other agents can read.

• Writes a progress.md you can actually review: recent work and next steps, not a dump of internal state.
• Keeps role.md current, so it stays clear what this agent is for and how it operates.
• Records session summaries carrying the decisions, links and preferences that came out of each spate of work, and tracks longer objectives in task files it updates as work progresses.
• Finds what changed across its own and shared namespaces with fulcra data-updates rather than listing directories.
• Checks progress reports for personal data and credentials before uploading them.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-memory.

Gives your agent the habit of checking what changed before it starts work, so a new session opens from current state and you are not asked to recap.

• Asks your permission first, then records the habit in its own memory so the scan runs at the start of each session.
• Runs fulcra data-updates for the window since its last check, which summarizes recent ingestion and file changes across your datastore in one call.
• Notices which team and memory files moved without downloading them, and fetches only the ones the current task needs.
• Checks its team inbox for coordination messages left by other agents or by you.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-situational-awareness.

Stores your preferences as records in your account rather than in one agent's memory, so every agent you connect starts from the same set. The agent loads them at the start of a session, applies them, and adds new ones as you state them.

• Creates a "User Preference" custom annotation type on first run and reuses it after that.
• Loads every recorded preference at session start, and where two conflict it honors the most recent one.
• Captures what you actually said: explicit asks, corrections, and patterns you confirmed when asked.
• Will not capture silent inferences, one-off task context, credentials, health details you did not ask it to store, or another person's preferences.
• Records aversions as well as preferences, so an agent also knows what not to suggest.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-prefs.

Snapshots an agent's identity and memory into your account so you can rewind it. The archive goes to one path in your file store, and because Fulcra versions files by path, repeated uploads build a timeline of that agent's states.

• Bundles SOUL.md, IDENTITY.md, MEMORY.md and the memory/ directory into memory.tar.gz, with generated restore instructions inside the archive.
• Runs on a schedule, from a heartbeat or alongside a memory sync.
• Takes a fresh backup before any rollback, so you can undo the rollback too.
• Clones an agent: the source agent backs up and reports its path, and the destination agent restores from it, then proves the clone worked by recalling specifics it has just learned.
• Requires your explicit confirmation before overwriting memory and identity, and checks for sensitive data before it uploads.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-agent-backup.

A community skill from an outside repository, kubla/a-particular-set-of-skills. It takes the Computer History summaries Codex already writes on your Mac and keeps them flowing into your account, so the record is not stranded in one tool.

• Previews the projected note, interval, tags, sources, data type and remote path before it authenticates or writes anything, so you can see exactly what would land in your account first.
• Sets up a token-free macOS LaunchAgent that sweeps roughly every ten minutes, and reports the authenticated owner, the computer name and the initial sweep counts when it is done.
• Keeps the projected note faithful to the summary Markdown, minus its trailing Citations section, and leaves the uploaded source file unchanged.
• Setup is convergent: it preserves your local configuration, projection map and projection status while refreshing the managed runtime.
• Uninstall removes only the local runtime and LaunchAgent. Everything already projected, and every source-file snapshot, stays in your account.

Requires macOS, Codex Computer History, uv, and network access. Open the source and read its spec before your agent runs it.

Gives a group of agents one place to work that you own. Team files live in your Fulcra file store under team/<team-name>/, so the work, the progress and the outputs outlast any single agent or session.

• Creates or joins a team, and asks you to define each agent's role instead of assuming one.
• Keeps a fixed structure per team: role, progress, completed work, sessions, tasks, a shared knowledge base, and artifacts.
• Runs an inbox per member. Agents leave each other timestamped messages and archive them once processed, and file versioning gives you an audit trail of when each message arrived and when it was handled.
• Requires an agent to update its progress files before it finishes, so the next agent, or the same one waking on a cron run, starts from accurate state.
• Warns before any cross-agent data transfer, because moving context between agents can expose it to a principal you never authorized.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-workspaces.

Sits on top of fulcra-workspaces and adds the parts a shared file store leaves open. A team gives agents shared memory and inboxes; this adds who is alive, who holds which role, how work is handed off, and whether anything is actually running.

• Six layers over one team namespace: presence, roles held by lease instead of by session, continuity checkpoints with a deterministic resume brief, an N-reviewer verdict tally, directed work with acknowledgements, and fleet health.
• Anything two agents must agree on is computed by a shared engine as a fold over stored state, so two agents reading the same state reach the same answer instead of each interpreting timestamps for itself.
• Ships a stdlib-only Python engine inside the skill, with no install step and nothing to resolve.
• Reads an inbox once per wake rather than running a resident listener, which keeps retry policy visible to you and stops a slow read from wedging a long-running process.

This is a community skill. Open the source before your agent runs it: the repository records exactly which upstream modules the vendored engine includes and excludes.

A manager's view of what an agent team has been doing, built over a fulcra-workspaces team namespace. It reads the team's own progress files, so nobody has to file a separate report.

• Distills the team role, the team progress and each member's progress into an executive summary written into the dashboard's data.
• Shows recent work logs, completion against outstanding work, and a timeline or Gantt view of milestones.
• Renders a word map over recent agent actions and task descriptions, so the team's actual focus is visible rather than asserted.
• Builds on fulcra-dashboard's static triad, and falls back to a simpler page, a rendered chart or an inline Markdown summary when that is not viable.

This is a community skill. Open the source to read the full component list before your agent builds one.

Takes a raw export you dropped into your file store and turns it into typed, queryable records. You upload a ZIP, JSON or CSV to ingest/; the agent profiles it, resolves or creates the schema, and writes the records.

• Triages the ingest/ directory, downloads new files and profiles their shape without asking you to map fields by hand.
• Keeps a source map so the same export never produces a duplicate schema, and generates deterministic ids so a re-run does not duplicate records.
• Can enrich records before writing them, adding cast and genre to a viewing history for instance, and can compute new tracks derived from what you already have.
• Archives each processed file with a timestamp and verifies the archive exists before removing the original.
• Logs every ingest with its source, date range and record count, then points you at your timeline to see the new data.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-ingest.

Turns "I want to track this" into a real schema in your account. The agent proposes a custom data type, creates it, records your first entry, and can show you the shape of the data before anyone commits to a full dashboard.

• Asks what you want to track, then creates the schema with uvx fulcra-api data-type create and keeps the ids it returns.
• Offers the Agent Visibility package when what you want to see is what background agents and teams are getting done.
• Records your first data point with you, or explains how another skill or app will do it automatically.
• Can put up a quick single-file HTML preview so you see the layout before the real thing gets built.
• Hands off to fulcra-dashboard for the full view, and writes the data types into the team knowledge base when a team is using them.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-tracking.

A Python package for descriptive analysis of your own data, built so the raw records stay on your machine. It fetches records or metric time series through the CLI, normalizes them into DataFrames, and produces summaries you can read or publish.

• Pulls from uvx fulcra-api get-records and uvx fulcra-api metric-time-series, or reads a local JSON, JSONL or CSV export.
• Computes missingness, numeric summaries, categorical frequencies, boolean ratios, datetime ranges and grouped summaries.
• Emits auditable JSON, or an OKF-ready report carrying the question, the data used, the methods, the findings, the caveats and the next steps.
• Keeps raw personal data local by default and uploads only sanitized summaries or artifacts you approved.
• Stops at descriptive statistics on purpose. Modeling, forecasting and causal work are out of scope.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-analytics.

Scaffolds a build-less dashboard over your Fulcra data: Alpine.js for state, vanilla CSS for styling, no framework toolchain. It runs on localhost by default, and only an isolated public/ directory is ever meant to be deployed.

• Generates a static triad of page, state script and styles, divided by banner comments so an agent can edit one region without unpicking the rest.
• Adds interactive charts with D3 or Plotly, or renders them in Python when a static image is the better answer.
• Falls back deliberately when the full build is not viable: a simpler bespoke page, a rendered chart image, or Markdown and ASCII in the chat.
• Separates the working directory, which holds your full datasets, from the public/ directory that is the only thing you publish.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-dashboard.

A local administration interface for your Fulcra setup, kept separate from the dashboard on purpose. It can read your file store and send commands to your agent, so it binds to localhost and is never published to the web.

• Scaffolds an Alpine.js panel and a Python backend into a directory you name.
• Includes a Chat Envoy: the backend exposes unread messages, and a small background loop hands them to your agent, so you can talk to it from the panel.
• Includes a file store explorer for browsing what is actually in your account.
• Themes itself to whatever you ask for while keeping the layout intact, so it stays usable at any width.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-control-panel.

A Cookbook recipe run as a workflow. It hands the weeknight dinner decision to an agent that knows tonight's specifics, instead of leaving it to a 7pm brain that has already spent its judgment.

• Starts with a standing dinner brief: your usual goal, your constraints and dislikes, your bedtime, and your fallbacks for a hard training day or a bad night's sleep.
• Adds the three facts that change daily: last night's sleep, whether you trained, and what you have eaten so far.
• Connected to Fulcra, your agent reads those signals itself instead of waiting for you to report them, so the context assembles without the nightly data entry.
• Closes the loop with a two-week alternation: some nights the agent picks, some nights you do, judged on one metric you already capture.

Connect your agent first at fulcradynamics.com/connect/claude or fulcradynamics.com/connect/chatgpt, or point any MCP-capable agent at https://mcp.fulcradynamics.com/mcp. Then open the recipe and paste the prompt at the end of it.

A Cookbook recipe run as a workflow. It builds your agent's picture of your fitness from what you actually did, not from the plan you wrote, so next week's suggestions fit the week you really have.

• Reconstructs the last two weeks of movement day by day, including the sessions you skipped and why. The skips carry as much signal as the sessions.
• States your body's limits as operational facts rather than diagnoses, so nothing gets suggested that you already know hurts.
• Adds a thirty-second report after each session: how it felt, where it was uneven, how your energy ran afterwards.
• Asks for the next seven days rather than a twelve-week program, then corrects what comes back. The corrections are the teaching.

Connect your agent first at fulcradynamics.com/connect/claude or fulcradynamics.com/connect/chatgpt, or point any MCP-capable agent at https://mcp.fulcradynamics.com/mcp. Then open the recipe and paste the prompt at the end of it.

A worked example of sharing without merging ownership. Two people each keep their own viewing history in their own account, share a narrow slice of it, and get recommendations neither history would produce alone.

• Each participant ingests their own Netflix or Letterboxd export with fulcra-ingest, then creates a narrow, preferably time-bounded share. The agent shows you the exact command before it runs, and never shares everything.
• Enriches titles with genre, cast and other features, caching progress as it goes so a long run survives an interruption.
• Scores unseen candidates against both histories, applies explicit vetoes, then re-ranks for novelty, availability, runtime and franchise fatigue.
• Returns five to ten picks with a separate reason for each person, plus its confidence, its assumptions, and how to revoke the share.
• Keeps the session in a workspace so another agent can resume it, while raw histories and anything derived from a partner's data stay out of it.

This is a community skill. Open the source to read the scoring model and the consent rules before your agent runs it.