What powers an AI that truly understands your projects and actions? In one word:
ActionGraph. This is the core underlying system design that gives ActionBoard its contextual
smarts. If ActionBoard’s user interface is the friendly face you interact with, the ActionGraph is
the brain behind the scenes, quietly mapping out everything and making sense of it all. But what
exactly is ActionGraph, and why is it so pivotal to achieving “true intelligence” in our platform?
Let’s dive in, in plain language.
At its heart, ActionGraph is a knowledge graph tailored for actions and project data. Think of a
knowledge graph as a giant network of interconnected facts and concepts. Instead of data sitting
in isolated silos (like tasks in a list, or documents in a folder), everything is linked. In
ActionGraph’s case, every task, goal, team member, document, and dependency becomes a
node in a network, and relationships (edges) describe how they influence each other. For
example, if Task A must finish before Task B can start, that’s a link in the graph. If Alice is the
owner of Task A, that’s another link. If Task A relates to a project goal “Increase user
engagement,” link that too. Over time you get a rich web of information – essentially a living
map of your project or even your entire portfolio of projects.
Why go to this trouble? Because it gives our AI something meaningful to reason over. Traditional
project tools might have all the same pieces of data, but they’re not connected. By connecting
them, ActionGraph enables the AI to traverse those links and understand context. One industry
analysis put it nicely: knowledge graphs enable “unprecedented levels of contextual
understanding and reasoning” for AI systems smythos.com. In our case, that means the AI doesn’t
just see a task with a due date; it sees how that task interrelates with others, what objectives it
feeds into, who’s involved, and even historical patterns from similar tasks. It’s the difference
between reading a single page versus understanding an entire book where everything is
referenced.
Let’s illustrate with a simple scenario: Suppose you have a project with tasks A, B, and C. A and
B must both finish before C can start. Traditional software might represent that with a
dependency list for C saying “Predecessors: A, B.” ActionGraph goes further – it records that
relationship in the graph and also knows what kind of dependency it is (finish-to-start, perhaps).
Now, imagine task B is being worked on by two departments (say Engineering and Design).
ActionGraph captures that collaboration link too. And task B is tied to a milestone or OKR
(Objective/Key Result) the company cares about – log that link. What emerges is a subgraph for
task B that connects people, timelines, prerequisites, and strategic goals. If later something
changes – say Engineering reassigns a person or task A is delayed – the AI can follow those
connections through the ActionGraph to see that Engineering’s change -> affects Task B ->
which in turn endangers Task C and the project’s KPI. This chain reasoning is exactly what a
human PM does mentally, but our AI can do it instantly across hundreds of tasks. It’s able to
answer not just “what’s happening now?” but “what does this impact?” because the knowledge
network is in place.
Another big advantage of ActionGraph is knowledge reuse. Remember how earlier we
emphasized that our system learns from past projects? ActionGraph is the mechanism for that.
When a project is completed, its graph (tasks, outcomes, etc.) becomes part of our knowledge
base (with appropriate abstraction to protect specifics if needed). So if you kick off a new project
that’s similar to a past one, the AI can recognize subgraphs – structures in the ActionGraph that
resemble what happened before. For instance, it might detect, “This new marketing campaign
project has a structure very similar to last year’s campaign – similar sequence of tasks and
goals.” Through ActionGraph, the AI essentially recalls what issues happened last time (maybe
the “Design review” task was a bottleneck) and can warn you or adjust predictions accordingly.
It’s as if the tool has a memory of all project graphs it has seen. Traditional approaches without a
graph would struggle to do this pattern matching across projects, because the data isn’t
interconnected or normalized in a way that’s easy to search for patterns. Our graph acts like a
library of action patterns the AI can draw from.
One might ask: how is ActionGraph built? Under the hood, it leverages graph database
technology and a schema we developed specifically for actions and projects. Each node has
properties (a task node has attributes like status, due date, etc., a person node has a role, skills,
etc., a goal node might have success criteria). The edges also have types (dependency,
ownership, related-to, part-of-phase, etc.). This schema allows us to run graph algorithms and
queries efficiently. For example, our AI might run a shortest-path algorithm to find if there’s a
way to reach a goal faster, or a centrality algorithm to see which task is most critical (has many
downstream dependencies). These aren’t things we expose directly to users, but the insights
bubble up through the UI as recommendations or warnings.
ActionGraph isn’t static; it updates in real-time as the project evolves. Mark a task as completed?
The graph updates that node’s status, and the AI immediately knows to activate any tasks that
depended on it. Change a deadline? The due date property shifts, and the AI might re-evaluate
the schedule impact by looking at the graph relationships. It’s like having a living model of your
project that stays in sync with reality. This dynamic updating is crucial for the dual retrieval
system we’ll discuss in the next blog – because the graph is always current, one half of our
retrieval (the graph-based half) is always pulling from the latest structured knowledge.
To put it in more relatable terms, imagine how a navigation app (like Google Maps) works: it has
a graph of roads and traffic. If a road closes or there’s congestion, that graph updates and the app
can immediately reroute you. ActionGraph does something analogous for projects – it constantly
recalculates the “route” of your project as conditions change, thanks to its rich map of tasks
(roads) and their interconnections. Without such a map, an AI is stuck reacting to events in
isolation. With ActionGraph, the AI navigates the terrain of your project with foresight.
One of the most exciting aspects of ActionGraph is how it lays the groundwork for future
capabilities. Because we model not just tasks but also knowledge (like documents or
requirements related to tasks), we can integrate external knowledge bases into the graph too. For
example, if there’s a regulatory document that impacts five tasks, that document can be a node
linked to those tasks. Tomorrow, if an update happens to that regulation, the AI could traverse the
graph and pinpoint which tasks/projects are affected. Think about the power of that in fields like
healthcare, finance, or software compliance – the system could instantly propagate knowledge
changes to project plans. This is how we start to approach a truly intelligent assistant: one that
keeps track of not only what you explicitly told it, but also the implicit knowledge and external
factors that bear on your work.
By unveiling ActionGraph, we hope you see why we invested so much in this design. It’s not just
a tech buzzword; it’s the very structure that allows ActionBoard to be context-aware, learning,
and proactive. In our next installment, we’ll delve into how ActionBoard’s AI uses this graph in
tandem with other AI techniques (like natural language understanding and vector search) – a
combination we call the Dual Retrieval System. If ActionGraph is the brain, the dual retrieval
system is how that brain thinks and finds answers in both structured and unstructured data. Get
ready for a peek into a truly cutting-edge approach that blends the best of both worlds for
information retrieval.
