The road to August 17: software should remember

There is a particular kind of confidence that only appears in product demos.

The repository is clean. The prompt is tidy. The agent knows exactly what to do. Nothing has an owner, a budget, a history, a dependency, or a customer waiting on the other side.

Then Monday arrives.

The company has twenty-seven repositories, six versions of the truth, three people who remember why the billing service is strange, and an agent that can write code faster than it can understand consequences.

That gap is where Konteks began.

This did not start as an AI product

Refactory began in 2015 with a stubborn belief: people learn software engineering by doing real work, not by watching theory from a safe distance. Its first vocational program put learners beside experienced engineers on actual projects. The work became an engineering practice serving companies in Indonesia and abroad.

Real projects leave marks. They teach you that code is rarely the whole problem. Ownership matters. The reason behind a decision matters. The system boundary matters. The person who approves the change matters. The cost of being wrong matters.

Over the years, Refactory built products to reduce the operational sprawl around software delivery. Those efforts taught us an expensive lesson: putting more work into one interface does not automatically create shared understanding.

The missing product was not another dashboard.

It was context.

The bet we made in 2024

Refactory began investing seriously in AI in 2024. We believed it would change how software was built—not merely how quickly someone could complete a line of code, but how teams would understand systems, plan change, and carry work from intent to evidence.

Belief arrived before the machinery. For years, models could assist with fragments of engineering work, but they could not reliably hold the context, use the tools, and stay with a real software change long enough to finish it responsibly.

Over the last four months, that changed. Models became markedly more capable, while a new generation of coding harnesses gave them the workspaces, tools, feedback loops, and validation needed to take on substantial engineering work. A direction we had believed in for years finally became something we could build around.

We had also begun onboarding a few early clients into agentic software workflows. Those engagements brought the hard questions into focus: Which system does this change belong to? Which repositories are involved? What should a person approve? How do we know what the agent actually changed? What did the work cost, and what should the next run remember?

The recurring answer became Konteks. What began as a disciplined way to deliver agentic work with clients became a product: durable software context, governed execution, and evidence that survives the session.

At first, we thought the problem was the interface

Our earliest versions focused on navigation: how a person would move through systems, repositories, agents, and work. We wanted AI to feel native instead of bolted onto a conventional console.

Those discussions were useful. They were also symptoms.

Every time we followed a thread far enough, the same failures appeared:

• an agent guessed because it could not see the real source of truth;
• a repository was selected without preserving why it belonged to a system;
• a new session forgot what the previous session had learned;
• UI, API, and MCP offered different versions of the product;
• a plan could begin before a person understood its cost or consequences;
• output looked complete while evidence remained scattered elsewhere.

We were arranging the furniture while the house had no memory.

The boundary that changed the product

Konteks now begins with a Software System—the same kind of durable system boundary used in C4 thinking and represented in a Backstage catalog.

A System can contain many sessions. A session can work across one repository or many. Repositories become Components that the System remembers. When a later session starts, a person can say “update checkout” instead of rebuilding the context from repository URLs and configuration details.

That sounds simple. Good product ideas often do after the difficult part has been removed.

The model gives every participant the same backstage:

Software System
├── Session: investigate checkout failures
│   ├── Component: checkout-api
│   └── Component: payment-worker
└── Session: reduce retry noise
    └── refers to the same known Components naturally

Zero gives people the visual workspace. MCP gives external agents the same governed capability. The catalog keeps the durable memory. Konteks turns approved intent into isolated, multi-repository work.

One product. Two entrances. No secret second reality for agents.

An estimate is a promise about honesty

Agentic software tools are very good at beginning work. Companies need systems that know when not to begin.

Before a chargeable stage runs, Konteks shows the scope, expected Story Points, budget effect, approval boundary, and separate model-provider cost status. If the estimate cannot be produced honestly, work should not quietly proceed as though the cost were zero.

The loop is:

1. Ask for an outcome in natural language.
2. Ground the request in the selected System and known Components.
3. Review a versioned Costed Change Proposal and upfront estimate.
4. Let a human approve the exact scope and maximum.
5. Execute through governed agents and isolated repositories.
6. Receive a Value Receipt that explains what was spent, what shipped, and why reality differed from the estimate.
7. Use eligible history from the same tenant to explain a better estimate next time.

We do not sell model tokens. Every published plan is bring-your-own-key. Story Points pay for the governed platform work around the model: orchestration, execution, validation, evidence, and control.

The distinction matters. Trust generally begins where the footnote would have been.

The workforce has to move too

We do not believe the future of software is only a technology upgrade. Agentic workflows change how people frame a problem, review work, make decisions, and take responsibility for an outcome. A powerful model in an unprepared organization creates novelty before it creates leverage.

That is why agentic training and onboarding are part of the service around Konteks. Refactory works with engineers, technical leaders, product teams, and reviewers to identify useful first workflows, build practical skills, define human approval habits, and learn how to measure the work without surrendering judgment to the agent.

The goal is not to teach everyone a fashionable prompt. It is to help the workforce become more capable as the tools become more capable.

Why the product looks a little playful

Serious software does not need to look joyless.

Konteks keeps its matcha palette and its small main character because software engineering is still a human craft. The pixel edges are a reminder that every enormous system is eventually made from small, exact decisions. The playful parts invite curiosity. The product underneath is disciplined because curiosity without discipline is merely a longer incident report.

August 17

We are aiming to launch Konteks on August 17, Indonesia’s Independence Day. 🇮🇩

It is a date about agency and responsibility: the freedom to choose a direction, and the discipline to own what follows. That feels right for a product designed to give teams more capable agents without asking them to surrender judgment.

The remaining work is not a theatrical checklist. We are running the product end to end through Zero, MCP, real repositories, approvals, delivery, and evidence. A feature is not finished because it looks complete. It is finished when a person and an agent can achieve the same intended outcome and the system can prove what happened.

Refactory has always valued real work over theory, data over assumption, and execution over plans. Konteks is what those values look like after years of building software—and after learning, repeatedly, that speed without shared context only helps a team arrive at the wrong place earlier.

The countdown has started.

On August 17, we intend to ship a product that remembers enough for your agents to be useful, and is honest enough for your company to trust them.

Read more about the history behind the team at Refactory, or start building in Zero.