> ## Documentation Index
> Fetch the complete documentation index at: https://developers.within.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# The technical track

> Build compound agents in the coding harness your engineers already use, grounded in how your business actually runs.

This track is for developers and AI platform teams. You work in the coding harness your engineers already use, such as [Codex](/install/codex), [Claude Code](/install/claude-code), or the [Gemini CLI](/install/gemini-cli), and build compound agents at the code level.

The non-technical track builds skills and simple agents. This track builds the compound ones.

## The Agent Development Kit

The Agent Development Kit (ADK) defines the build sequence from a business objective to a tested, deployed agent. Each stage uses current [Company Brain](/concepts/process-index) evidence where the process is relevant to the decision.

> [!NOTE]
>
> You do not install a separate ADK package. The method is served through the MCP. Once Within is connected in your harness, the assistant calls [`get_agent_builder_instructions`](/tools/agent-builder) and follows the returned method, retrieving the supporting resources it names.

Because the method is served at build time, start each new build by retrieving the current instructions. Version the code, configuration, evaluations, and evidence baseline that the build produces in your own repository.

```mermaid theme={null}
flowchart LR
  H[Coding harness] --> M[Within MCP]
  M --> A[Agent Builder tools serve the methodology]
  M --> C[Company Brain: processes and artifacts]
  A --> B[Your agent]
  C --> B
```

## The sequence

The assistant guides the sequence and produces the build artifacts in your harness. Your team supplies the objective, constraints, approvals, and technical judgment. Company Brain evidence grounds process claims, but it does not replace security review, system documentation, or runtime testing.

The prompts below are what a builder types in their harness with Within connected.

**1. Objective**

Define the business objective and the technology stack the solution should live within. Giving both the goal and the stack constraints up front makes recommendations far more useful and deployable.

```text theme={null}
I want to optimize order-to-cash on AWS Bedrock with the Claude Agent SDK.
Help me frame the objective and constraints.
```

See [Set the objective](/transformation/objective) for what a well-formed one looks like.

**2. Companion**

Make sure the Company Brain covers the area in question. Where coverage is thin, deploy [Companion](/concepts/discover-structure-improve) against it before building.

```text theme={null}
Does our Company Brain have enough coverage of accounts payable to build
against? Where is it thin?
```

**3. Analyze**

Produce a current-state read from observed data: pain points, bottlenecks, time and motion, systems in use, and bright spots.

```text theme={null}
Give me a current-state read of procure-to-pay: pain points, bottlenecks,
time-and-motion, systems, and bright spots.
```

**4. Recommend and select**

Generate candidate use cases and screen them against evidence, expected impact, feasibility, and required controls.

```text theme={null}
Find automation opportunities in this process, rank them by evidence and
expected impact, and flag which are feasible to ship now.
```

Apply the screens in [Pick the right use case](/transformation/use-case-selection). The [Find transformation opportunities](/guides/find-opportunities) guide covers the tool chain behind this step.

**5. Design**

Produce the agent specification, effectively a PRD for the agent: scope, governance, credentials, and flow.

```text theme={null}
Spec this out: what should the invoice-exception agent do, which tools and
credentials, and where are the human approval points?
```

**6. Build**

Generate the agent: code, skills, and configuration.

```text theme={null}
Build it. Generate the agent against this spec.
```

**7. Test**

Generate and run evaluations before release. Include ordinary cases, edge cases, malformed or missing inputs, and requests the agent should refuse.

```text theme={null}
Test this. Generate an eval suite with edge cases and should-not-fire cases,
run it against approved test data, and report the evidence for each result.
```

**8. Deploy**

Ship into your environment.

```text theme={null}
Deploy this. Set it up as a Managed Agent in our environment.
```

## What you build

Compound agents, managed, orchestrated, or custom SDK-built, and deterministic Integration Flows. See [What you can build](/transformation/what-you-can-build) for how the primitives differ and when each one fits.

Two controls run throughout. Material process claims cite observed data, and a person approves the design and release gates.

## Artifacts are part of the value

The current-state read and recommendation can be generated as visual HTML artifacts. Use them to review the evidence, assumptions, controls, and proposed change with stakeholders before implementation.

## Keeping agents current

An agent can drift as the process changes. See [Keep agents current](/transformation/maintain-agents) for how to compare an existing build with current Company Brain evidence and decide what needs to be retested.

## Within support

Within's team can work with your engineers on implementation, production readiness, and evaluation design.

## Related

> **[Agent Builder tools](/tools/agent-builder)**
>
> The two tools that serve the methodology.

> **[Build skills, agents, and automations](/guides/agent-builder)**
>
> Use the same flow from any MCP client.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.