EN
Contact
Menu
Journal

ANNOUNCEMENT

Agent systems

Introducing Colony: personal agents with memory and tools

Give an agent an ongoing job, a place to work and memory it can use next time. Colony is opening for technical previews.

Good AI Labs 3 min read

Explore Colony Technical preview
Colony · Recorded session and saved artifact

RECORDED APP COMMIT

A scientific calculator,
saved as six files.

The app, its data and its change history remain available for the next request.

Commit
e790c96
Recorded change
6 files · 450 inserted lines

SAVED APPLICATION

  • ui/index.htmlInterface
  • ui/styles.cssStyles
  • ui/app.jsCalculator & graph
  • data/latest.jsonApp data
  • manifest.jsonApp definition
  • .gitignoreFile exclusions

Checked in the reopened appsqrt(9) 3

Inspect the original session and app captures

01 / Recorded build session

Excerpt of a recorded Colony app-building session showing the file commit and its report of the scientific calculator.

02 / Saved application

The actual saved calculator app, reopened and checked with sqrt(9), returning 3.
An app that remains after the conversation. A record of the saved calculator project. The original session and app captures are available above; the reopened app was checked with sqrt(9) = 3. An earlier interface capture, cropped to the app work. This example does not measure general coding reliability.

Colony is a personal agent system for work that continues across conversations. Give an agent a project, access to its tools and a result to work toward. Its files, memory and responsibilities stay available across conversations.

We built Colony because useful work rarely fits inside one exchange. An experiment needs checking later. A project has decisions worth remembering. A procedure that worked once should be available the next time it is needed.

From a conversation to saved work

Colony / From a task to saved work

A working app, saved for the next task.

  1. 01 / Build

    Work in a real project.

    An agent uses the project's files and permitted tools to produce an app. In this recorded session, Colony built a scientific calculator and committed six files with 450 inserted lines.

    Recorded app commite790c966 files · 450 inserted lines
    • ui/index.htmlInterface
    • ui/styles.cssStyles
    • ui/app.jsLogic & graph
    • data/latest.jsonApp data
    • manifest.jsonDefinition
    • .gitignoreExclusions

    A saved application the next conversation can use.

    Recorded commit e790c96. The saved project contains the interface, logic, app data and definition.

  2. 02 / Check

    Inspect what was actually saved.

    We reopened the application and checked sqrt(9), which returned 3. The image is the saved app itself, so the result can be inspected alongside the session record.

    Reopened application / Actual capture

    The saved scientific calculator, checked with sqrt(9), returning 3

    sqrt(9)3

    Actual app capture. One arithmetic check demonstrates this saved artifact, not exhaustive correctness.

  3. 03 / Continue

    Give the next request somewhere to begin.

    The app files, data and change history stay in the workspace. A later conversation can inspect or change the same project. Agent memory and reusable skills support that continuing work.

    Retained projecte790c966 files · 450 inserted lines
    • ui/index.htmlInterface
    • ui/styles.cssStyles
    • ui/app.jsLogic & graph
    • data/latest.jsonApp data
    • manifest.jsonDefinition
    • .gitignoreExclusions
    Next requestThe same files, data and history
    The same files, app data and version history remain available for later work.

Based on the recorded calculator session and reopened application. This example does not measure general coding reliability.

The example above comes from an app-building session. Colony wrote the calculator’s interface and logic, then committed the files. We reopened the saved app and checked that sqrt(9) returns 3. Expand the figure above to inspect the original session excerpt and the app capture.

The important object is the app on disk. A later request can change those files, inspect the history or continue the same project. A conversation has produced something the next conversation can use.

An agent with somewhere to work

Colony agents can work in repositories, run commands, research the web and use connected tools. On a Mac, they can also read application windows and operate their controls with the permissions you grant. You can talk by text or voice, assign a background goal, set a reminder or schedule a recurring task. Reports return to the conversation, with an interruption when you asked for one.

An agent can also build a small app: a tracker for experiments, a reading list or a dashboard with scheduled data updates. Several agents can share a project, exchange messages and carry out dependent steps.

Keep what the work teaches you

Colony stores inspectable memories and full tool results outside the model’s immediate context. Large outputs are retrieved in relevant pieces. Completed background work can become a proposed skill for you to review and install; repeated operations can become reusable tools.

Keeping an agent running has a compute cost. Colony records model usage and provider-reported cache use, and lets you inspect the context sent to the model. Memory consolidation and skill drafting also use inference. Our next question is how much this accumulated work helps on later tasks under the same model and compute budget.

Colony runs on a computer you control, with a local model server or a hosted endpoint you choose. Background work requires that computer to stay available. The current build is private, and we are opening technical previews for people with an ongoing job to put it to work on.

PRODUCT DETAILS

Colony

Persistent agents that work in your tools, remember your projects and build what you need.

More from the lab