Inspiration

Six months ago, an engineer wrote a comment on a Jira ticket:

"I'm concerned the new onboarding flow is inaccessible to screen reader users. We're deferring the fix because we have no accessibility specialist. Let's revisit once the new design system is ready."

The launch shipped. The ticket was closed. The engineer moved to another team.

Then the company hired an accessibility specialist. The new design system shipped. Every condition for fixing the problem was now true, and nobody remembered there was a problem.

This happens in every organisation, every week. Nobody is careless. It happens because work is tracked in tickets, but intentions are not. An idea gets rejected because "the timing isn't right". A manager promises something after the launch, then changes teams. Three people raise the same concern months apart, and it never becomes an official risk. When the ticket closes, the why closes with it.

Atlassian's Teamwork Graph shows that context is what turns AI into real help. We asked a different question:

What about the context that has quietly stopped being visible?

What it does

STILLHERE gives the things that matter a continuing existence inside Jira. Memory tells you what happened. Continuity tells you what is still unresolved, and the exact moment it matters again.

Contextual Reawakening

🔁 Contextual Reawakening: the flagship

Reminders fire on a timer. STILLHERE fires when the world changes. Every new Jira issue and comment is compared with the original reasons each unresolved intention was put on hold. When a blocker seems to have gone, the intention reawakens, and it explains why in plain language:

  • ✅ Revisit condition may now be met: "once the new design system is ready"
  • ✅ Original constraint may no longer apply: "we have no accessibility specialist"

In our live demo, a concern from a closed ticket comes back within a minute of an unrelated "Welcome Aisha, our new accessibility specialist" ticket. Nobody had to search for it. It's always labelled a signal for a person, not a decision.

🧠 Intent Capture

STILLHERE reads Jira issues and comments for ideas ("what if we…"), promises ("we'll fix this after launch") and concerns ("I'm worried…"). For each one it captures what tickets never store:

  • the constraint: why it couldn't happen then;
  • the revisit condition: what would make it matter again;
  • the voices: everyone who has raised it.

A person confirms every suggestion before anything is saved.

🔗 Intent Persistence

A closed ticket does not close the intention. When work is marked Done but a promise or concern inside it is still unresolved, STILLHERE flags it as continuity debt: "ticket closed, intention open."

🗣️ Recurring voices

When a customer reports the same problem months later, STILLHERE doesn't create another forgotten ticket. It records a second voice on the original concern. Concerns that keep coming back become visible: "raised 2 times".

📊 The Things Still Waiting

A single page of real counts from Jira, with nothing estimated by AI: unresolved promises, reawakened intentions, recurring concerns and continuity debt.

⚖️ Follow-through gaps

Themes raised again and again, next to how often they were actually resolved: "onboarding: raised 3 times, fulfilled 0." This shows the gap between what an organisation says matters and what it follows through on, using plain counts, never scoring people.

🤝 Continuity Handoff

When someone moves on, their open commitments, the concerns they raised and the ideas they started are handed to the next owner in one click. The original contributor keeps the credit. People can move on without their work becoming invisible.

🤖 The STILLHERE Rovo agent

Ask "What is still waiting for us?", "Why was this deferred, and what has changed?" or "Prepare a continuity handoff for Sam." The agent answers from the same records and permissions as the UI and cites issue keys. Its 7 actions are reusable tools that any other Rovo agent can call.

How we built it

STILLHERE is a native Atlassian Forge app, with no external servers and no egress.

How it's built

Layer What we used
Listening Product event triggers (avi:jira:created:issue, avi:jira:commented:issue, avi:jira:updated:issue) and a daily scheduled trigger that re-checks recent work
Thinking An explainable continuity engine in plain JavaScript: intent extraction, constraint and revisit-condition matching, change-signal detection and recurrence detection, unit-tested around the demo story
Remembering A Continuity Graph in Forge Key-Value Storage. Each record links the intent, its context, its voices, the evidence since, the Jira issues involved and a full timeline
Showing A UI Kit global page and a Jira issue panel on every issue
Talking A Rovo agent (rovo:agent) with 7 action modules: get-still-waiting, find-intentions, get-intention, scan-issue, capture-intention, update-intention-status and prepare-handoff
Trust The Jira REST API v3 called as the user wherever a person is involved. Every view is filtered to issues the viewer is allowed to open

Why rules, not a black box? Organisational memory only works if people trust it. Every capture and every reawakening lists the exact reasons it fired, and Rovo explains results without inventing them. One shared service layer powers both the UI and the agent, so people and AI always see the same truth.

Challenges we ran into

  • "Similar" is not "changed". Matching on topic alone produced noise. Reawakening only fires when a recorded constraint or revisit condition is actually addressed, not just when the topic overlaps.
  • Good news that looked like bad news. "Our new accessibility specialist" was first flagged as an accessibility concern. We tightened the rules so that only a stated problem counts, and locked it in with a test.
  • Trust before automation. We chose to have nothing happen automatically. Every capture needs confirmation, and every reawakening is a signal, not a verdict.
  • Permissions in the background. Triggers need app context to read new work, but nothing is ever shown to someone who couldn't open the source issue.
  • UI details. UI Kit text fields dropped keystrokes when controlled, so we rebuilt every input to be uncontrolled.

Accomplishments that we're proud of

  • The reawakening moment. A forgotten concern from a closed ticket returns within a minute of a seemingly unrelated welcome message, with a full explanation of why. That moment is the whole idea in one screen.
  • A new data model for work. Constraint, revisit condition and voices give an intention a life of its own, independent of tickets, projects and people.
  • Privacy by design. No employee scoring, no inferred feelings and no private conversations. Only work-related statements, with attribution and permissions.
  • Complete and real. It's deployed to production, installable with one link, has a working demo story generator, and was tested end to end on a live Jira site.

What we learned

The most valuable context in an organisation is often what didn't happen, and why. Tickets record decisions; they almost never record the conditions behind them. Once you capture those conditions, a computer can recognise the exact moment a decision deserves another look, which no reminder or search box can do.

What's next for STILLHERE

  • Teamwork Graph: publish continuity records into the graph, and read people-and-work relationships from it to find the right new owner.
  • Confluence: capture deferred decisions from meeting notes and design docs.
  • Semantic matching next to the rule engine, to catch paraphrases, while keeping every result explainable.
  • Per-person consent for Continuity Handoffs, then a Marketplace listing.

Try it in 2 minutes

  1. Install STILLHERE with the installation link and open Apps → STILLHERE → Demo → Create the demo story.
  2. Create an issue titled "Welcome Aisha, our new accessibility specialist" (the full text is on the Demo tab).
  3. Within a minute, refresh STILLHERE and watch the forgotten concern reawaken.

People move on. Priorities change. The things worth remembering shouldn't disappear.

Built With

Share this project:

Updates

Submission history