Augnes — Continuous Perspective for AI-Assisted Work

Augnes gives AI-assisted projects a continuous perspective that carries context, decisions, and learning forward across tasks, tools, and sessions.

Comment

Inspiration

AI tools are becoming useful for projects that last longer than a single session. As that happens, keeping the project’s context becomes more important.

A new session often begins with a partial reconstruction of earlier work. Decisions may be buried in chat logs, uncertain conclusions may be repeated as facts, and a completed run may be treated as proof that the task itself succeeded.

I started Augnes with a simple question: how can an AI-assisted project maintain a consistent perspective across tasks, tools, and sessions?

In Augnes, a project perspective includes its goals, relevant context, evidence, decisions, open questions, and lessons from previous work. The purpose is to help each task begin from the project’s current state instead of rebuilding that state from scattered records.

An early version of Augnes placed third in the OpenAI Discord community’s “Build a System, Not a Prompt” developer challenge. During Build Week, I expanded it into a working local-first system with project onboarding, Codex integration, structured verification, reviewed state changes, bounded automation, and a reference operator interface.

What it does

Augnes is a continuity engine for AI-assisted projects.

ChatGPT, Codex, and other native tools perform the work. Augnes keeps track of the project context around that work. It records what was attempted, what was observed, what remains uncertain, what the user decided, and what should be carried into the next task.

The main workflow is:

  1. Project Home shows the current project, active work, pending decisions, and the next useful action.
  2. Augnes gathers the relevant project context and sends it to Codex.
  3. The result returns as a structured RunReceipt.
  4. Augnes checks the original success criteria against observations, tests, artifacts, skipped checks, and missing information.
  5. Semantic Workbench shows the original goal, the observed result, remaining uncertainty, and the proposed change.
  6. The user reviews the proposal and makes a decision.
  7. An authorized Transition applies the approved change to the project state.
  8. Future tasks receive updated context based on accepted results and decisions.
  9. Inspector shows the sources and lineage behind each result, decision, and applied change.

Execution, verification, review, and application are separate steps. A completed run does not automatically mean that the task succeeded, and a proposal does not automatically become part of the project state.

This Build Week submission focuses on the operational Core and a reference operator interface. The current interface exposes much of the underlying verification, authority, and lineage model. It is closer to an operating console for the engine than to the final end-user experience.

The goal of this submission is to demonstrate that the full continuity loop works across project state, Codex execution, verification, human review, applied changes, and later context.

How I built it

Augnes is local-first and uses a provider-neutral Core.

The application is built with TypeScript, Next.js, and SQLite. OpenAI is the reference integration through:

  • a Model Gateway that uses the Responses API;
  • a Codex App Server integration for project-scoped execution and structured results.

The Core stores task context, run receipts, evidence, claims, proposals, decisions, transitions, and later context as separate records. Explicit references connect those records and preserve the history behind each change.

The current interface has three main areas:

  • Project Home for resuming and coordinating work;
  • Semantic Workbench for verification and decisions;
  • Inspector for reviewing sources, authority, and lineage.

Augnes also supports bounded automation. It can select an eligible task, check the relevant policy, issue a capability grant, run the task, create a receipt, and prepare a proposal. The result then returns to the user for review.

I used GPT-5.6 in ChatGPT for architecture analysis, implementation planning, product decisions, and review. Codex implemented scoped changes, wrote tests, and opened pull requests.

Each major pull request went through type checking, production builds, integration tests, authority tests, operability tests, and browser end-to-end tests.

Challenges

Preserving uncertainty

Many tasks do not have a simple success or failure result.

A run may complete successfully while one of the original requirements remains unverified. Augnes keeps that criterion unresolved until enough support is available.

This gives later work a more accurate starting point and makes missing verification easier to identify.

Separating different kinds of authority

Permission to run a task is different from permission to change the project’s accepted context.

Augnes separates execution, proposal, review, authorization, and application. Codex can perform useful work, while the user remains responsible for deciding which results become durable project state.

Building an interface for a detailed engine

Augnes tracks relationships between context packets, run receipts, evidence, claims, proposals, decisions, transitions, and later use.

The current reference interface exposes much of this structure so the Core can be inspected and tested. This makes the interface more technical than the user-facing workspace I ultimately want to build.

R7 organized the interface into three clearer roles. Project Home supports resumption, Semantic Workbench supports review and decisions, and Inspector provides detailed lineage when it is needed.

Developing Augnes across many AI-assisted sessions

The development process became a practical example of the problem Augnes is designed to solve.

The work was spread across ChatGPT conversations, Codex threads, pull requests, issues, tests, documentation, and design decisions. As the project grew, it became harder to keep the original goals, current implementation, available evidence, and next priorities aligned.

An individual pull request could be technically correct while the overall product direction became less clear. Reviewing the project often required reconstructing earlier decisions and checking whether the latest implementation still matched the intended design.

This made development slower and more difficult. It also gave me a concrete test case for Augnes. A long-running AI-assisted project needs more than stored history. It needs a maintained perspective that connects goals, evidence, decisions, current state, and the next action.

What I learned

Building Augnes showed me that continuity requires more than saving additional history.

A useful project perspective should connect goals, observations, uncertainty, decisions, and current state. That structure helps the next task begin from the right place.

I also learned that human review works best when the proposed effect is visible before the project state changes.

The development process reinforced another lesson: strong individual agent runs do not automatically produce a coherent long-term product. The project also needs a way to preserve direction across many runs, tools, and decisions.

What’s next

The next phase is to build a simpler user-facing workspace on top of the continuity engine demonstrated here.

Project Home will become a clearer overview of the project’s goals, recent progress, pending decisions, and next action. Semantic Workbench will guide users through review in simpler language. Detailed protocol records and lineage will remain available through Inspector when they are needed.

I also plan to improve onboarding, mobile use, installation, recovery, portability, and sharing.

In the longer term, I want Augnes to support continuous project perspectives across software development, research, planning, analysis, and creative work.

Built With

  • agentic
  • agents
  • ai
  • api
  • automation
  • codex
  • context
  • developer
  • human-in-the-loop
  • local-first
  • management
  • mcp
  • next.js
  • node.js
  • openai
  • react
  • responses
  • semantic
  • sqlite
  • tools
  • typescript
  • workflows
Share this project:

Updates